@duckcodeailabs/dql-cli 1.12.2 → 1.12.3

package/dist/local-runtime.js

@@ -968,7 +968,10 @@ export async function startLocalServer(opts) {
         return result;
     };
     await reloadSemanticLayer();
-    await refreshLocalMetadataCatalog(projectRoot);
+    // Normal startup reuses the fingerprinted local catalog when its inputs are
+    // unchanged. Explicit refresh, save, and certification paths still request
+    // the default forced rebuild below.
+    await refreshLocalMetadataCatalog(projectRoot, undefined, undefined, false);
     const startupDbtManifestPath = resolveDbtManifestPath(projectRoot, projectConfig);
     if (startupDbtManifestPath && !isAgentProjectIndexReady(projectRoot)) {
         try {
@@ -1338,8 +1341,14 @@ export async function startLocalServer(opts) {
                 throw error;
         }
         const semanticDriver = semanticConnection?.driver;
+        const defaultExecutionTarget = executionTargetDescriptor({});
+        const semanticConnectionName = request.executionTarget?.target === 'connection'
+            ? request.executionTarget.connectionName
+            : defaultExecutionTarget.target === 'connection'
+                ? defaultExecutionTarget.connectionName
+                : undefined;
         const semanticTableMapping = semanticLayer && semanticConnection
-            ? await resolveSemanticTableMapping(executor, semanticConnection, semanticLayer, projectRoot)
+            ? await resolveSemanticTableMapping(executor, semanticConnection, semanticLayer, projectRoot, semanticConnectionName)
             : undefined;
         const requestedDomain = normalizeAgentRunDomain(agentRunWorkspaceValue(request, 'domain'));
         const requestedPurpose = agentRunWorkspaceValue(request, 'purpose');
@@ -1527,9 +1536,9 @@ export async function startLocalServer(opts) {
                 ? { resolvedAnalyticalPlan: routeDecision.resolvedAnalyticalPlan }
                 : {}),
             analyticalReferenceInstant: new Date().toISOString(),
-            executeCertifiedBlock: (node, invocation) => executeCertifiedBlockForAgent(node, invocation, semanticConnection),
-            executeGeneratedSql: (sql, artifact) => executeGeneratedArtifactForAgent(request.question, sql, artifact, semanticConnection),
-            executeDqlArtifact: (artifact) => executeArtifactReferenceForAgent(artifact, request.question, semanticConnection),
+            executeCertifiedBlock: (node, invocation) => executeCertifiedBlockForAgent(node, invocation, semanticConnection, semanticConnectionName),
+            executeGeneratedSql: (sql, artifact) => executeGeneratedArtifactForAgent(request.question, sql, artifact, semanticConnection, semanticConnectionName),
+            executeDqlArtifact: (artifact) => executeArtifactReferenceForAgent(artifact, request.question, semanticConnection, semanticConnectionName),
             getSchemaContext: (question, preparedContextPack) => getSchemaContextForAgent(question, preparedContextPack, semanticConnection, request.executionTarget?.target === 'connection'
                 ? request.executionTarget.connectionName
                 : undefined),
@@ -2713,6 +2722,18 @@ export async function startLocalServer(opts) {
         const preparedMetadataFingerprint = isAgentProjectIndexReady(projectRoot)
             ? currentMetadataFingerprint(projectRoot)
             : undefined;
+        const targetDescriptor = executionTargetDescriptor(request);
+        const targetConnectionName = targetDescriptor.target === 'connection'
+            ? targetDescriptor.connectionName
+            : undefined;
+        let runtimeSchemaSnapshot;
+        if (targetConnectionName) {
+            const targetConnection = resolveNamedConnection(targetConnectionName);
+            const activeScope = targetConnection
+                ? optionalActiveConnectionMetadataScope(projectRoot, projectConfig, targetConnection, targetConnectionName)
+                : null;
+            runtimeSchemaSnapshot = runtimeSchemaSnapshotForAgentConnection(projectRoot, targetConnectionName, activeScope?.scopeFingerprint);
+        }
         const task = buildLocalContextPack(projectRoot, {
             question: request.question,
             focusObjectKey: request.selectedEvidenceId,
@@ -2724,7 +2745,11 @@ export async function startLocalServer(opts) {
                 || topicRelation === 'shift'
                 ? topicRelation
                 : undefined,
+            // Reuse remains available for fast follow-ups; the context-pack freshness
+            // contract now binds it to this runtime snapshot's connection/generation.
+            reusePolicy: 'seed',
             preparedMetadataFingerprint,
+            ...(runtimeSchemaSnapshot ? { runtimeSchemaSnapshot } : {}),
             surface: 'notebook',
             selectedContext: {
                 selectedObject: request.selectedObject,
@@ -2995,7 +3020,7 @@ export async function startLocalServer(opts) {
             cells: snapshotCells,
         });
     };
-    const executeDqlArtifactSourceForAgent = async (source, metadata = {}, invocationInput, executionConnection) => {
+    const executeDqlArtifactSourceForAgent = async (source, metadata = {}, invocationInput, executionConnection, executionConnectionName) => {
         const invocation = prepareBlockInvocation({
             source,
             parameters: invocationInput?.parameters,
@@ -3011,7 +3036,7 @@ export async function startLocalServer(opts) {
         const activeConnection = requireActiveConnection(executionConnection);
         const precompiledSemanticQuery = Boolean(extractBlockStudioSql(source));
         const tableMapping = !precompiledSemanticQuery
-            ? await resolveSemanticTableMapping(executor, activeConnection, semanticLayer, projectRoot)
+            ? await resolveSemanticTableMapping(executor, activeConnection, semanticLayer, projectRoot, executionConnectionName)
             : undefined;
         const semanticCompose = semanticLayer
             ? await composeSemanticBlockSqlForRuntime(source, semanticLayer, {
@@ -3080,7 +3105,7 @@ export async function startLocalServer(opts) {
             } : {}),
         };
     };
-    const executeCertifiedBlockByNameForAgent = async (blockName, invocationInput, requireCertified = false, executionConnection) => {
+    const executeCertifiedBlockByNameForAgent = async (blockName, invocationInput, requireCertified = false, executionConnection, executionConnectionName) => {
         const manifest = buildManifest({ projectRoot });
         const block = manifest.blocks[blockName];
         if (!block) {
@@ -3095,7 +3120,7 @@ export async function startLocalServer(opts) {
             path: block.filePath,
             domain: block.domain,
             chartType: block.chartType,
-        }, invocationInput, executionConnection);
+        }, invocationInput, executionConnection, executionConnectionName);
         return {
             ...result,
             dqlArtifact: {
@@ -3114,17 +3139,17 @@ export async function startLocalServer(opts) {
             },
         };
     };
-    const executeCertifiedBlockForAgent = async (node, invocationInput, executionConnection) => {
+    const executeCertifiedBlockForAgent = async (node, invocationInput, executionConnection, executionConnectionName) => {
         if (node.kind !== 'block') {
             throw new Error(`Certified ${node.kind} "${node.name}" is a navigation artifact and cannot be executed as a block.`);
         }
-        return executeCertifiedBlockByNameForAgent(node.name || node.nodeId.replace(/^block:/, ''), invocationInput, false, executionConnection);
+        return executeCertifiedBlockByNameForAgent(node.name || node.nodeId.replace(/^block:/, ''), invocationInput, false, executionConnection, executionConnectionName);
     };
     // Secondary agent surfaces use this compatibility callback. Delegate to the
     // same artifact-first path as Ask so research/app/notebook execution cannot
     // silently reintroduce a raw-SQL result followed by a different DQL artifact.
     const executeGeneratedSqlForAgent = async (sql, artifact) => executeGeneratedArtifactForAgent(artifact?.name ?? 'AI-generated query', sql, artifact);
-    const executeArtifactReferenceForAgent = async (artifact, question, executionConnection) => {
+    const executeArtifactReferenceForAgent = async (artifact, question, executionConnection, executionConnectionName) => {
         const invocation = prepareBlockInvocation({
             source: artifact.source,
             parameters: artifact.parameterValues,
@@ -3139,7 +3164,7 @@ export async function startLocalServer(opts) {
             question,
             parameters: invocation.values,
             rowLimit: artifact.limit ?? 200,
-        }, executionConnection);
+        }, executionConnection, executionConnectionName);
         return {
             ...result,
             dqlArtifact: {
@@ -3151,9 +3176,9 @@ export async function startLocalServer(opts) {
             },
         };
     };
-    const executeGeneratedArtifactForAgent = async (question, sql, seed, executionConnection) => {
+    const executeGeneratedArtifactForAgent = async (question, sql, seed, executionConnection, executionConnectionName) => {
         const artifact = generatedSqlArtifactContract(question, sql, seed);
-        return executeArtifactReferenceForAgent({ ...artifact, limit: seed?.limit ?? artifact.limit ?? 200 }, question, executionConnection);
+        return executeArtifactReferenceForAgent({ ...artifact, limit: seed?.limit ?? artifact.limit ?? 200 }, question, executionConnection, executionConnectionName);
     };
     /**
      * EXP-001: execution host for the deliberately narrow non-governed lane.
@@ -3277,7 +3302,7 @@ export async function startLocalServer(opts) {
         const activeScope = schemaConnection
             ? optionalActiveConnectionMetadataScope(projectRoot, projectConfig, schemaConnection, executionConnectionName ?? projectConfig.defaultConnectionName ?? 'default')
             : null;
-        const activeRuntimeSnapshot = latestRuntimeSchemaSnapshotForProject(projectRoot);
+        const activeRuntimeSnapshot = latestRuntimeSchemaSnapshotForProject(projectRoot, executionConnectionName);
         const hasActivatedMetadataGeneration = Boolean(activeScope
             && activeRuntimeSnapshot?.scopeFingerprint === activeScope.scopeFingerprint
             && activeRuntimeSnapshot.status !== 'stale');
@@ -3289,9 +3314,6 @@ export async function startLocalServer(opts) {
             // row value must not turn a warm Ask into an information_schema scan over
             // thousands of enterprise tables; only field-scoped value probes are live.
             const enriched = await enrichAgentSchemaContextWithValueMatches(question, catalogContext, executor, schemaConnection, valueGrounding.searchSafeColumns);
-            if (!hasActivatedMetadataGeneration) {
-                recordAgentRuntimeSchemaSnapshot(projectRoot, catalogContext, 'catalog runtime schema');
-            }
             return enriched;
         }
         // An activated, scope-qualified warehouse generation is the complete warm
@@ -3307,7 +3329,7 @@ export async function startLocalServer(opts) {
             const enriched = valueGrounding.mode === 'safe_automatic'
                 ? await enrichAgentSchemaContextWithValueMatches(question, schemaContext.ranked, executor, schemaConnection, valueGrounding.searchSafeColumns)
                 : schemaContext.ranked;
-            recordAgentRuntimeSchemaSnapshot(projectRoot, schemaContext.snapshot, 'question-scoped information_schema search');
+            recordAgentRuntimeSchemaSnapshot(projectRoot, schemaContext.snapshot, 'question-scoped information_schema search', executionConnectionName);
             return enriched;
         }
         catch {
@@ -6519,6 +6541,12 @@ export async function startLocalServer(opts) {
                             res.end(serializeJSON({ ok: true }));
                             return;
                         }
+                        if (req.method === 'DELETE' && !action) {
+                            store.deleteThread(threadId);
+                            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(serializeJSON({ ok: true }));
+                            return;
+                        }
                         // Explicit promotion — the ONLY path from conversation into durable
                         // memory ("remember this"). Deliberate user act, tagged for audit.
                         if (req.method === 'POST' && action === 'promote') {
@@ -9884,7 +9912,7 @@ export async function startLocalServer(opts) {
                     res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                     res.end(serializeJSON({
                         scope,
-                        status: warehouseMetadataStatus(projectRoot, scope.scopeFingerprint),
+                        status: warehouseMetadataStatus(projectRoot, scope.scopeFingerprint, connectionId),
                     }));
                 }
                 catch (error) {
@@ -9904,7 +9932,7 @@ export async function startLocalServer(opts) {
                     res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                     res.end(serializeJSON({
                         scope,
-                        status: warehouseMetadataStatus(projectRoot, scope.scopeFingerprint),
+                        status: warehouseMetadataStatus(projectRoot, scope.scopeFingerprint, connectionId),
                     }));
                 }
                 catch (error) {
@@ -9933,7 +9961,7 @@ export async function startLocalServer(opts) {
                     res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                     res.end(serializeJSON({
                         scope: synced.scope,
-                        status: warehouseMetadataStatus(projectRoot, synced.scope.scopeFingerprint),
+                        status: warehouseMetadataStatus(projectRoot, synced.scope.scopeFingerprint, connectionId),
                     }));
                 }
                 catch (error) {
@@ -9959,7 +9987,7 @@ export async function startLocalServer(opts) {
                     res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                     res.end(serializeJSON({
                         scope: synced.scope,
-                        status: warehouseMetadataStatus(projectRoot, synced.scope.scopeFingerprint),
+                        status: warehouseMetadataStatus(projectRoot, synced.scope.scopeFingerprint, connectionId),
                     }));
                 }
                 catch (error) {
@@ -9996,7 +10024,7 @@ export async function startLocalServer(opts) {
                     connectorStatus,
                     metadataScope,
                     metadataStatus: metadataScope
-                        ? warehouseMetadataStatus(projectRoot, metadataScope.scopeFingerprint)
+                        ? warehouseMetadataStatus(projectRoot, metadataScope.scopeFingerprint, defaultKey)
                         : warehouseMetadataStatus(projectRoot),
                 }));
                 return;
@@ -12524,7 +12552,11 @@ table: ${table}${tagList}
                 return;
             }
             const content = readFileSync(filePath);
-            res.writeHead(200, { 'Content-Type': contentTypeFor(filePath) });
+            res.writeHead(200, {
+                'Content-Type': contentTypeFor(filePath),
+                'Cache-Control': staticResponseCacheControl(filePath),
+                'Content-Length': content.byteLength,
+            });
             res.end(content);
         })().catch((error) => {
             // API-007/E2E-014: no rejected request promise may terminate the local
@@ -13480,10 +13512,10 @@ export function compileBlockStudioManifest(projectRoot, projectConfig = loadProj
     _lineageCache.delete(projectRoot);
     return manifest;
 }
-async function refreshLocalMetadataCatalog(projectRoot, manifest, semanticLayer) {
+async function refreshLocalMetadataCatalog(projectRoot, manifest, semanticLayer, force = true) {
     try {
         await ensureMetadataCatalogFresh(projectRoot, {
-            force: true,
+            force,
             ...(manifest ? { manifest } : {}),
             ...(semanticLayer ? { semanticLayer } : {}),
         });
@@ -15691,6 +15723,16 @@ function contentTypeFor(filePath) {
             return 'text/plain; charset=utf-8';
     }
 }
+export function staticResponseCacheControl(filePath) {
+    // Vite fingerprints every generated asset filename, so a new DQL build gets
+    // a new URL and the previous file is safe to retain indefinitely. Keep the
+    // HTML shell revalidated so it can point at the current asset hashes.
+    if (extname(filePath).toLowerCase() === '.html')
+        return 'no-cache';
+    return filePath.split(sep).includes('assets')
+        ? 'public, max-age=31536000, immutable'
+        : 'no-cache';
+}
 function listProjectFiles(projectRoot) {
     const allowed = new Set(['.dql', '.sql', '.md', '.json', '.csv', '.yaml', '.yml', '.dqlnb']);
     const files = [];
@@ -16132,11 +16174,11 @@ function parseSemanticBlockConfig(source) {
         limit: limitMatch ? Number.parseInt(limitMatch[1], 10) : undefined,
     };
 }
-export async function resolveSemanticTableMapping(executor, connection, semanticLayer, projectRoot) {
+export async function resolveSemanticTableMapping(executor, connection, semanticLayer, projectRoot, connectionId) {
     if (!semanticLayer)
         return undefined;
     if (projectRoot) {
-        const snapshot = latestRuntimeSchemaSnapshotForProject(projectRoot);
+        const snapshot = latestRuntimeSchemaSnapshotForProject(projectRoot, connectionId);
         if (snapshot?.scopeFingerprint && snapshot.tables.length) {
             return buildSemanticTableMapping(semanticLayer, snapshot.tables.map((table) => ({
                 table_catalog: table.catalogOrDatabase,
@@ -16158,16 +16200,30 @@ export async function resolveSemanticTableMapping(executor, connection, semantic
     }
 }
 export function buildSemanticTableMapping(semanticLayer, rows) {
-    const dbTableNames = new Set();
-    const schemaQualified = new Map();
+    const normalizeIdentifierPart = (value) => value
+        .trim()
+        .replace(/^["'`\[]|["'`\]]$/g, '')
+        .toLowerCase();
+    const normalizeRelation = (value) => value
+        .split('.')
+        .map(normalizeIdentifierPart)
+        .filter(Boolean)
+        .join('.');
+    const candidates = [];
     for (const row of rows) {
+        const catalog = String(row['table_catalog'] ?? '');
         const schema = String(row['table_schema'] ?? '');
         const name = String(row['table_name'] ?? '');
-        const relation = typeof row['table_relation'] === 'string' ? row['table_relation'] : undefined;
+        const relation = typeof row['table_relation'] === 'string' && row['table_relation'].trim()
+            ? row['table_relation']
+            : [catalog, schema, name].filter(Boolean).join('.');
         if (!name)
             continue;
-        dbTableNames.add(name);
-        schemaQualified.set(name, relation ?? (schema ? `${schema}.${name}` : name));
+        candidates.push({
+            name: normalizeIdentifierPart(name),
+            relation,
+            normalizedRelation: normalizeRelation(relation),
+        });
     }
     const tableMapping = {};
     const allSemanticTables = new Set();
@@ -16182,9 +16238,19 @@ export function buildSemanticTableMapping(semanticLayer, rows) {
     for (const semTable of allSemanticTables) {
         if (!semTable)
             continue;
-        if (dbTableNames.has(semTable) && schemaQualified.has(semTable)) {
-            tableMapping[semTable] = schemaQualified.get(semTable);
-        }
+        const normalizedSemantic = normalizeRelation(semTable);
+        const semanticLeaf = normalizedSemantic.split('.').at(-1);
+        if (!semanticLeaf)
+            continue;
+        const qualifiedMatches = candidates.filter((candidate) => candidate.normalizedRelation === normalizedSemantic
+            || candidate.normalizedRelation.endsWith(`.${normalizedSemantic}`));
+        const leafMatches = candidates.filter((candidate) => candidate.name === semanticLeaf);
+        const matches = qualifiedMatches.length > 0 ? qualifiedMatches : leafMatches;
+        // Never guess when the same semantic leaf exists in several schemas. A
+        // qualified semantic relation can disambiguate; otherwise the semantic
+        // runtime must surface the modeling gap instead of executing the wrong one.
+        if (matches.length === 1)
+            tableMapping[semTable] = matches[0].relation;
     }
     return Object.keys(tableMapping).length > 0 ? tableMapping : undefined;
 }
@@ -21433,11 +21499,36 @@ export function runtimeSnapshotStale(projectRoot, maxAgeMs = RUNTIME_SNAPSHOT_MA
         return false;
     }
 }
-function recordAgentRuntimeSchemaSnapshot(projectRoot, schemaContext, source) {
+/**
+ * Resolve only metadata captured for the connection executing this Ask run.
+ * Returning an explicit empty snapshot is a correctness boundary: callers pass
+ * it into the context builder so it cannot silently fall back to another
+ * connection's project-global runtime FTS rows.
+ */
+export function runtimeSchemaSnapshotForAgentConnection(projectRoot, connectionId, expectedScopeFingerprint) {
+    const snapshot = latestRuntimeSchemaSnapshotForProject(projectRoot, connectionId);
+    const current = Boolean(snapshot
+        && snapshot.status !== 'stale'
+        && (!expectedScopeFingerprint
+            || !snapshot.scopeFingerprint
+            || snapshot.scopeFingerprint === expectedScopeFingerprint));
+    return current
+        ? snapshot
+        : {
+            version: 1,
+            connectionId,
+            status: 'partial',
+            source: 'selected connection has no current runtime metadata',
+            tables: [],
+        };
+}
+function recordAgentRuntimeSchemaSnapshot(projectRoot, schemaContext, source, connectionId) {
     if (schemaContext.length === 0)
         return;
     try {
         recordRuntimeSchemaSnapshot(projectRoot, {
+            ...(connectionId ? { connectionId } : {}),
+            status: 'partial',
             source,
             tables: schemaContext.map((table) => ({
                 relation: table.relation,