@duckcodeailabs/dql-agent 1.12.2 → 1.12.4

package/dist/metadata/catalog.js

@@ -516,6 +516,7 @@ export async function buildLocalContextPack(projectRoot, request) {
     const runtimeCatalog = openMetadataCatalog(projectRoot);
     try {
         const mode = request.mode ?? 'question';
+        const includeDraftBlocks = allowsDraftBlockRetrieval(request);
         const followUp = normalizeFollowUpContext(request.followUp);
         const questionPlan = buildAnalysisQuestionPlan(request.question, followUp ?? undefined);
         if (questionPlan.requestedShape.filters.length > 0) {
@@ -542,7 +543,18 @@ export async function buildLocalContextPack(projectRoot, request) {
             && request.conversationTopicRelation !== 'shift'
             ? runtimeCatalog.getContextPack(request.priorContextPackId)
             : null;
-        const priorPackFresh = Boolean(priorPack && priorPack.freshness.fingerprint === catalog.state('fingerprint'));
+        const runtimeSchemaIdentityMatches = Boolean((priorPack?.freshness.runtimeSchemaConnectionId ?? undefined)
+            === (request.runtimeSchemaSnapshot?.connectionId ?? undefined)
+            && (priorPack?.freshness.runtimeSchemaScopeFingerprint ?? undefined)
+                === (request.runtimeSchemaSnapshot?.scopeFingerprint ?? undefined)
+            && (priorPack?.freshness.runtimeSchemaGenerationId ?? undefined)
+                === (request.runtimeSchemaSnapshot?.generationId ?? undefined)
+            && (priorPack?.freshness.runtimeSchemaCapturedAt ?? undefined)
+                === (request.runtimeSchemaSnapshot?.capturedAt ?? undefined));
+        const priorPackFresh = Boolean(priorPack
+            && priorPack.freshness.fingerprint === catalog.state('fingerprint')
+            && runtimeSchemaIdentityMatches
+            && (includeDraftBlocks || !priorPack.objects.some(isUncertifiedDqlBlock)));
         if (priorPack
             && priorPackFresh
             && request.conversationTopicRelation === 'refinement'
@@ -562,6 +574,18 @@ export async function buildLocalContextPack(projectRoot, request) {
                     catalogPath: snapshotPath,
                     builtAt: catalog.state('built_at'),
                     fingerprint: catalog.state('fingerprint'),
+                    ...(request.runtimeSchemaSnapshot?.connectionId
+                        ? { runtimeSchemaConnectionId: request.runtimeSchemaSnapshot.connectionId }
+                        : {}),
+                    ...(request.runtimeSchemaSnapshot?.scopeFingerprint
+                        ? { runtimeSchemaScopeFingerprint: request.runtimeSchemaSnapshot.scopeFingerprint }
+                        : {}),
+                    ...(request.runtimeSchemaSnapshot?.generationId
+                        ? { runtimeSchemaGenerationId: request.runtimeSchemaSnapshot.generationId }
+                        : {}),
+                    ...(request.runtimeSchemaSnapshot?.capturedAt
+                        ? { runtimeSchemaCapturedAt: request.runtimeSchemaSnapshot.capturedAt }
+                        : {}),
                 },
             };
             delete reusedPayload.id;
@@ -599,7 +623,8 @@ export async function buildLocalContextPack(projectRoot, request) {
         // Skill guidance is injected only through selectContextPackSkills below.
         // Leaving it in generic FTS results would bypass status/domain/area/exclusion
         // eligibility simply because a word in its body matched the question.
-        const retrievalObjects = (rows) => scopeObjects(rows).filter((row) => row.objectType !== 'skill');
+        const retrievalObjects = (rows) => scopeObjects(rows).filter((row) => row.objectType !== 'skill'
+            && (includeDraftBlocks || !isUncertifiedDqlBlock(row)));
         const snapshotRetrieval = await retrieveMetadataSnapshotCandidates(catalog, {
             question: request.question,
             searchQueries,
@@ -793,6 +818,18 @@ export async function buildLocalContextPack(projectRoot, request) {
                 catalogPath: snapshotPath,
                 builtAt: catalog.state('built_at'),
                 fingerprint: catalog.state('fingerprint'),
+                ...(request.runtimeSchemaSnapshot?.connectionId
+                    ? { runtimeSchemaConnectionId: request.runtimeSchemaSnapshot.connectionId }
+                    : {}),
+                ...(request.runtimeSchemaSnapshot?.scopeFingerprint
+                    ? { runtimeSchemaScopeFingerprint: request.runtimeSchemaSnapshot.scopeFingerprint }
+                    : {}),
+                ...(request.runtimeSchemaSnapshot?.generationId
+                    ? { runtimeSchemaGenerationId: request.runtimeSchemaSnapshot.generationId }
+                    : {}),
+                ...(request.runtimeSchemaSnapshot?.capturedAt
+                    ? { runtimeSchemaCapturedAt: request.runtimeSchemaSnapshot.capturedAt }
+                    : {}),
             },
         };
         const packPayload = { ...payload };
@@ -916,11 +953,18 @@ export function recordRuntimeSchemaSnapshot(projectRoot, snapshot) {
         catalog.close();
     }
 }
-/** The most-recent stored live-warehouse schema snapshot for a project, or null. */
-export function latestRuntimeSchemaSnapshotForProject(projectRoot) {
+/**
+ * The most-recent stored live-warehouse schema snapshot for a project.
+ *
+ * When a connection id is supplied, never fall back to a snapshot captured for
+ * another connection. Ask may target a different warehouse connection than the
+ * project default, so a project-global "latest" snapshot is not safe evidence
+ * for planning or semantic table resolution.
+ */
+export function latestRuntimeSchemaSnapshotForProject(projectRoot, connectionId) {
     const catalog = openMetadataCatalog(projectRoot);
     try {
-        return catalog.latestRuntimeSchemaSnapshot();
+        return catalog.latestRuntimeSchemaSnapshot(connectionId);
     }
     finally {
         catalog.close();
@@ -2320,12 +2364,14 @@ export class MetadataCatalog {
     `);
         const txn = this.db.transaction(() => {
             insertSnapshot.run(id, cleanSnapshot.source ?? null, JSON.stringify(cleanSnapshot), capturedAt);
-            // Only the most-recent snapshot is ever read; rows otherwise accumulate one per
-            // question forever. Keep a small margin and prune the rest (P7).
+            // Preserve a bounded history across multiple named connections. Ask
+            // resolves the latest snapshot for its selected connection, so retaining
+            // only five project-global rows could evict a valid but less-recent
+            // warehouse as soon as another connection was refreshed repeatedly.
             this.db.prepare(`
         DELETE FROM runtime_schema_snapshots
         WHERE id NOT IN (
-          SELECT id FROM runtime_schema_snapshots ORDER BY captured_at DESC LIMIT 5
+          SELECT id FROM runtime_schema_snapshots ORDER BY captured_at DESC LIMIT 50
         )
       `).run();
             this.db.prepare('DELETE FROM runtime_value_fts').run();
@@ -2376,14 +2422,21 @@ export class MetadataCatalog {
         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(`
+    latestRuntimeSchemaSnapshot(connectionId) {
+        const rows = 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;
+      LIMIT 50
+    `).all();
+        for (const row of rows) {
+            const snapshot = safeRuntimeSchemaSnapshot(safeJson(row.payload_json, null));
+            if (!snapshot)
+                continue;
+            if (!connectionId || snapshot.connectionId === connectionId)
+                return snapshot;
+        }
+        return null;
     }
     getContextPack(id) {
         const row = this.db.prepare('SELECT payload_json FROM context_packs WHERE id = ?').get(id);
@@ -4354,6 +4407,18 @@ function findExactCertifiedObject(question, intent, objects) {
 function isCertifiedMetadataObject(object) {
     return object.status === 'certified' || object.status === 'approved' || object.payload?.certification === 'certified';
 }
+function isUncertifiedDqlBlock(object) {
+    return object.objectType === 'dql_block' && !isCertifiedMetadataObject(object);
+}
+function allowsDraftBlockRetrieval(request) {
+    if (request.includeDraftBlocks === true)
+        return true;
+    if (request.surface === 'block')
+        return true;
+    if (request.mode && request.mode !== 'question')
+        return true;
+    return /\b(?:draft|review|edit|certif(?:y|ied|ication)|block studio|this block)\b/i.test(request.question);
+}
 function objectNameInQuestion(question, object) {
     const q = normalizeSearchText(question);
     const name = normalizeSearchText(object.name);
@@ -5770,12 +5835,26 @@ export function isFilterOnlyRefinement(prior, next) {
         return false;
     const priorShape = prior.requestedShape;
     const nextShape = next.requestedShape;
+    // Every check below is a set comparison, so two plans the planner extracted
+    // NOTHING from compared equal and were declared "the same query with
+    // different filters". Two unrelated questions the vocabulary does not cover
+    // then reused the earlier context pack wholesale — including its committed
+    // route decision. Reuse requires actual evidence of sameness on both sides.
+    if (!hasPlanSignal(prior) || !hasPlanSignal(next))
+        return false;
     return setEqual(priorShape.measures, nextShape.measures)
         && setEqual(priorShape.dimensions, nextShape.dimensions)
         && setEqual(priorShape.requiredOutputs, nextShape.requiredOutputs)
         && (priorShape.grain ?? '') === (nextShape.grain ?? '')
         && setEqual(prior.entities.map((entity) => entity.text.toLowerCase()), next.entities.map((entity) => entity.text.toLowerCase()));
 }
+/** Did the planner actually read anything out of this question? */
+function hasPlanSignal(plan) {
+    return plan.requestedShape.measures.length > 0
+        || plan.requestedShape.dimensions.length > 0
+        || plan.requestedShape.requiredOutputs.length > 0
+        || plan.entities.length > 0;
+}
 function setEqual(a, b) {
     const setA = new Set(a.map((value) => value.toLowerCase()));
     const setB = new Set(b.map((value) => value.toLowerCase()));