@duckcodeailabs/dql-cli 1.12.1 → 1.12.3

package/dist/local-runtime.js

@@ -40,7 +40,7 @@ import { observeWarehouseTargetIdentity } from './semantic-execution/connection-
 import { configuredWarehouseTargetIdentity } from './semantic-execution/connection-identity.js';
 import { executeTargetBoundSemanticQuery, semanticExecutionFailureCode, semanticExecutionFailureDetails, } from './semantic-execution/execution-gateway.js';
 import { buildSemanticTargetBinding } from './semantic-execution/target-binding.js';
-import { normalizeConnectionMetadataScope, syncWarehouseMetadata, warehouseMetadataStatus, } from './warehouse-metadata.js';
+import { discoverWarehouseMetadataScopes, normalizeConnectionMetadataScope, syncWarehouseMetadata, warehouseMetadataStatus, } from './warehouse-metadata.js';
 import { NotebookDatasetWorkspace, } from "./notebook-datasets.js";
 import { prepareBlockInvocation } from './block-invocation.js';
 const NOTEBOOK_EXECUTE_PREVIEW_ROW_LIMIT = 500;
@@ -204,6 +204,18 @@ export function parseAgentRunRequestBody(body) {
     if (!question)
         return { error: 'question is required.' };
     const selectedObject = parseAgentRunSelectedObject(record.selectedObject);
+    const rawExecutionTarget = agentRunRecord(record.executionTarget)
+        ?? agentRunRecord(agentRunRecord(record.workspaceContext)?.executionTarget);
+    const executionTarget = rawExecutionTarget?.target === 'local'
+        ? { target: 'local' }
+        : rawExecutionTarget?.target === 'connection'
+            ? {
+                target: 'connection',
+                ...(agentRunString(rawExecutionTarget.connectionName)
+                    ? { connectionName: agentRunString(rawExecutionTarget.connectionName) }
+                    : {}),
+            }
+            : undefined;
     const workspaceContext = agentRunRecord(record.workspaceContext) ?? agentRunRecord(record.context);
     const signals = agentRunRecord(record.signals);
     const requestedMode = parseAgentRunRequestedMode(record.requestedMode) ?? parseAgentRunRequestedMode(record.mode);
@@ -219,6 +231,7 @@ export function parseAgentRunRequestBody(body) {
             intent: agentRunString(record.intent),
             signals: signals,
             selectedObject,
+            executionTarget,
             workspaceContext,
             conversationContext: agentRunRecord(record.conversationContext),
             history: parseAgentRunHistory(record.history),
@@ -887,6 +900,7 @@ export async function startLocalServer(opts) {
         }
         return requireActiveConnection(isConnectionConfig(body.connection) ? body.connection : connection);
     };
+    const resolveAgentRunExecutionConnection = (request) => resolveExecutionConnection(request.executionTarget ? { executionTarget: request.executionTarget } : {});
     const executionTargetDescriptor = (body) => {
         const target = body.executionTarget && typeof body.executionTarget === 'object'
             ? body.executionTarget
@@ -954,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 {
@@ -1312,17 +1329,26 @@ export async function startLocalServer(opts) {
         // Best-effort active warehouse dialect so Lane-2 semantic compiles emit
         // dialect-correct SQL (e.g. DATE_TRUNC / identifier quoting). Absent when no
         // connection is configured — the compiler then uses its default dialect.
-        let semanticDriver;
         let semanticConnection;
         try {
-            semanticConnection = requireActiveConnection();
-            semanticDriver = semanticConnection.driver;
+            semanticConnection = await resolveAgentRunExecutionConnection(request);
         }
-        catch {
-            semanticDriver = undefined;
+        catch (error) {
+            // An explicit target is a contract and must fail closed. Without one,
+            // conversational/non-data runs retain the existing no-connection path;
+            // any later analytical execution will surface the normal setup action.
+            if (request.executionTarget)
+                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');
@@ -1510,10 +1536,12 @@ export async function startLocalServer(opts) {
                 ? { resolvedAnalyticalPlan: routeDecision.resolvedAnalyticalPlan }
                 : {}),
             analyticalReferenceInstant: new Date().toISOString(),
-            executeCertifiedBlock: executeCertifiedBlockForAgent,
-            executeGeneratedSql: (sql, artifact) => executeGeneratedArtifactForAgent(request.question, sql, artifact),
-            executeDqlArtifact: (artifact) => executeArtifactReferenceForAgent(artifact, request.question),
-            getSchemaContext: getSchemaContextForAgent,
+            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),
         }, (turn) => {
             if (turn.kind === 'thinking')
                 onProgress?.(turn.text);
@@ -1762,7 +1790,7 @@ export async function startLocalServer(opts) {
                     }));
                 const exploration = await executeExploratoryCandidate(governedAnswer.exploratoryCandidate, explorationSchema, request.question, governedAnswer.contextPack?.questionPlan.requestedShape.topN?.scope === 'overall'
                     ? governedAnswer.contextPack.questionPlan.requestedShape.topN.n
-                    : undefined);
+                    : undefined, await resolveAgentRunExecutionConnection(request));
                 const probeSummary = exploration.proofs.length > 0
                     ? `${exploration.proofs.length} bounded join probe${exploration.proofs.length === 1 ? '' : 's'} completed.`
                     : 'No join probe was required for this query.';
@@ -2694,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,
@@ -2705,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,
@@ -2976,7 +3020,7 @@ export async function startLocalServer(opts) {
             cells: snapshotCells,
         });
     };
-    const executeDqlArtifactSourceForAgent = async (source, metadata = {}, invocationInput) => {
+    const executeDqlArtifactSourceForAgent = async (source, metadata = {}, invocationInput, executionConnection, executionConnectionName) => {
         const invocation = prepareBlockInvocation({
             source,
             parameters: invocationInput?.parameters,
@@ -2989,10 +3033,10 @@ export async function startLocalServer(opts) {
         if (invocation.unresolvedParameters.length > 0) {
             throw new Error(`I need values for: ${invocation.unresolvedParameters.join(', ')}.`);
         }
-        const activeConnection = requireActiveConnection();
+        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, {
@@ -3061,7 +3105,7 @@ export async function startLocalServer(opts) {
             } : {}),
         };
     };
-    const executeCertifiedBlockByNameForAgent = async (blockName, invocationInput, requireCertified = false) => {
+    const executeCertifiedBlockByNameForAgent = async (blockName, invocationInput, requireCertified = false, executionConnection, executionConnectionName) => {
         const manifest = buildManifest({ projectRoot });
         const block = manifest.blocks[blockName];
         if (!block) {
@@ -3076,7 +3120,7 @@ export async function startLocalServer(opts) {
             path: block.filePath,
             domain: block.domain,
             chartType: block.chartType,
-        }, invocationInput);
+        }, invocationInput, executionConnection, executionConnectionName);
         return {
             ...result,
             dqlArtifact: {
@@ -3095,17 +3139,17 @@ export async function startLocalServer(opts) {
             },
         };
     };
-    const executeCertifiedBlockForAgent = async (node, invocationInput) => {
+    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);
+        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) => {
+    const executeArtifactReferenceForAgent = async (artifact, question, executionConnection, executionConnectionName) => {
         const invocation = prepareBlockInvocation({
             source: artifact.source,
             parameters: artifact.parameterValues,
@@ -3120,7 +3164,7 @@ export async function startLocalServer(opts) {
             question,
             parameters: invocation.values,
             rowLimit: artifact.limit ?? 200,
-        });
+        }, executionConnection, executionConnectionName);
         return {
             ...result,
             dqlArtifact: {
@@ -3132,9 +3176,9 @@ export async function startLocalServer(opts) {
             },
         };
     };
-    const executeGeneratedArtifactForAgent = async (question, sql, seed) => {
+    const executeGeneratedArtifactForAgent = async (question, sql, seed, executionConnection, executionConnectionName) => {
         const artifact = generatedSqlArtifactContract(question, sql, seed);
-        return executeArtifactReferenceForAgent({ ...artifact, limit: seed?.limit ?? artifact.limit ?? 200 }, question);
+        return executeArtifactReferenceForAgent({ ...artifact, limit: seed?.limit ?? artifact.limit ?? 200 }, question, executionConnection, executionConnectionName);
     };
     /**
      * EXP-001: execution host for the deliberately narrow non-governed lane.
@@ -3144,8 +3188,8 @@ export async function startLocalServer(opts) {
      * existing read-only 200-row preview. Any malformed, broad, or unsupported
      * candidate remains review-required and is not executed automatically.
      */
-    const executeExploratoryCandidate = async (candidate, schemaContext = [], question = '', requestedTopN) => {
-        const activeConnection = requireActiveConnection();
+    const executeExploratoryCandidate = async (candidate, schemaContext = [], question = '', requestedTopN, executionConnection) => {
+        const activeConnection = requireActiveConnection(executionConnection);
         const preflight = repairExploratorySqlBeforeExecution(candidate.sql, schemaContext, question, activeConnection.driver);
         const boundedSql = applyRequestedTopNToExploratorySql(preflight.sql, requestedTopN);
         const repairs = boundedSql === preflight.sql
@@ -3236,42 +3280,40 @@ export async function startLocalServer(opts) {
                     return { proofs, sql: boundedSql, repairs, error: contradiction };
                 }
             }
-            const result = await executeGeneratedArtifactForAgent(question, boundedSql);
+            const result = await executeGeneratedArtifactForAgent(question, boundedSql, undefined, activeConnection);
             return { result, proofs, sql: boundedSql, repairs };
         }
         catch (error) {
             return { proofs, sql: boundedSql, repairs, error: error instanceof Error ? error.message : String(error) };
         }
     };
-    const getSchemaContextForAgent = async (question, preparedContextPack) => {
+    const getSchemaContextForAgent = async (question, preparedContextPack, executionConnection, executionConnectionName) => {
+        const schemaConnection = executionConnection ?? connection;
         const scanRuntimeSchema = async () => {
-            if (!connection)
+            if (!schemaConnection)
                 return { ranked: [], snapshot: [] };
-            const result = await executor.executePositional(buildRuntimeSchemaSearchSql(question), [], connection, { maxRows: 600, maxBytes: 2 * 1024 * 1024, batchSize: 200, deadlineMs: 30_000 });
+            const result = await executor.executePositional(buildRuntimeSchemaSearchSql(question), [], schemaConnection, { maxRows: 600, maxBytes: 2 * 1024 * 1024, batchSize: 200, deadlineMs: 30_000 });
             return {
                 ranked: buildAgentSchemaContext(question, result.rows),
                 snapshot: buildAgentSchemaContext(question, result.rows, { includeUnscored: true, limit: 100 }),
             };
         };
         const catalogContext = await buildAgentSchemaContextFromCatalog(projectRoot, question, preparedContextPack).catch(() => []);
-        const activeScope = connection
-            ? optionalActiveConnectionMetadataScope(projectRoot, projectConfig, connection, projectConfig.defaultConnectionName ?? 'default')
+        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');
         const valueGrounding = resolveAgentRuntimeValueGrounding(projectConfig);
         if (catalogContext.length > 0) {
-            if (!connection || valueGrounding.mode !== 'safe_automatic')
+            if (!schemaConnection || valueGrounding.mode !== 'safe_automatic')
                 return catalogContext;
             // The immutable dbt/DQL snapshot already owns schema discovery. A named
             // 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, connection, valueGrounding.searchSafeColumns);
-            if (!hasActivatedMetadataGeneration) {
-                recordAgentRuntimeSchemaSnapshot(projectRoot, catalogContext, 'catalog runtime schema');
-            }
+            const enriched = await enrichAgentSchemaContextWithValueMatches(question, catalogContext, executor, schemaConnection, valueGrounding.searchSafeColumns);
             return enriched;
         }
         // An activated, scope-qualified warehouse generation is the complete warm
@@ -3280,14 +3322,14 @@ export async function startLocalServer(opts) {
         // user may explicitly refresh the selected scope.
         if (hasActivatedMetadataGeneration)
             return [];
-        if (!connection)
+        if (!schemaConnection)
             return [];
         try {
             const schemaContext = await scanRuntimeSchema();
             const enriched = valueGrounding.mode === 'safe_automatic'
-                ? await enrichAgentSchemaContextWithValueMatches(question, schemaContext.ranked, executor, connection, valueGrounding.searchSafeColumns)
+                ? 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 {
@@ -6499,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') {
@@ -6732,6 +6780,7 @@ export async function startLocalServer(opts) {
                         hintId,
                         title: typeof body.title === 'string' ? body.title : undefined,
                         guidance: typeof body.guidance === 'string' ? body.guidance : undefined,
+                        lesson: parseHintLessonInput(body.lesson),
                         correctedSql: typeof body.correctedSql === 'string' ? body.correctedSql : undefined,
                         scope: rawScope ? {
                             metric: scopeValue('metric'),
@@ -6911,6 +6960,7 @@ export async function startLocalServer(opts) {
                         requiredEvaluation: correctionEvaluation,
                         hintTitle: typeof body.title === 'string' && body.title.trim() ? body.title.trim() : undefined,
                         hintGuidance: typeof body.guidance === 'string' && body.guidance.trim() ? body.guidance.trim() : undefined,
+                        lesson: parseHintLessonInput(body.lesson),
                         tags: Array.isArray(body.tags) ? body.tags.map(String) : undefined,
                     });
                     // `approve` is intentionally ignored: capture never promotes a hint.
@@ -9824,8 +9874,32 @@ export async function startLocalServer(opts) {
                 return;
             }
             const metadataScopePreviewMatch = path.match(/^\/api\/connections\/([^/]+)\/metadata-scope\/preview$/);
+            const metadataDiscoveryMatch = path.match(/^\/api\/connections\/([^/]+)\/metadata-scope\/discovery$/);
             const metadataScopeMatch = path.match(/^\/api\/connections\/([^/]+)\/metadata-scope$/);
             const metadataSyncMatch = path.match(/^\/api\/connections\/([^/]+)\/metadata-sync$/);
+            if (metadataDiscoveryMatch && req.method === 'POST') {
+                try {
+                    const connectionId = decodeURIComponent(metadataDiscoveryMatch[1]);
+                    const cfg = loadProjectConfig(projectRoot);
+                    const selectedConnection = projectConnectionById(projectRoot, cfg, connectionId);
+                    if (!selectedConnection)
+                        throw new Error(`Unknown connection "${connectionId}".`);
+                    const defaults = metadataScopeDbtDefaults(projectRoot, cfg);
+                    const discovery = await discoverWarehouseMetadataScopes({
+                        connectionId,
+                        executor,
+                        connection: selectedConnection,
+                        dbtRelations: defaults.relations,
+                    });
+                    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON(discovery));
+                }
+                catch (error) {
+                    res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({ error: error instanceof Error ? error.message : String(error) }));
+                }
+                return;
+            }
             if (metadataScopePreviewMatch && req.method === 'POST') {
                 try {
                     const connectionId = decodeURIComponent(metadataScopePreviewMatch[1]);
@@ -9838,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) {
@@ -9858,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) {
@@ -9887,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) {
@@ -9913,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) {
@@ -9950,7 +10024,7 @@ export async function startLocalServer(opts) {
                     connectorStatus,
                     metadataScope,
                     metadataStatus: metadataScope
-                        ? warehouseMetadataStatus(projectRoot, metadataScope.scopeFingerprint)
+                        ? warehouseMetadataStatus(projectRoot, metadataScope.scopeFingerprint, defaultKey)
                         : warehouseMetadataStatus(projectRoot),
                 }));
                 return;
@@ -12478,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
@@ -13434,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 } : {}),
         });
@@ -15438,6 +15516,24 @@ function internalDqlRelationIdValidationError(sql, subject) {
         return null;
     return `${subject} contains internal DQL graph relation identifier${internalIds.length === 1 ? '' : 's'} ${internalIds.join(', ')}. Use the physical database.schema.table relation instead, or choose Ask AI to fix from the notebook error.`;
 }
+function parseHintLessonInput(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const stringList = (field) => Array.isArray(raw[field])
+        ? raw[field].filter((item) => typeof item === 'string')
+        : undefined;
+    return {
+        version: 1,
+        category: typeof raw.category === 'string'
+            ? raw.category
+            : undefined,
+        rule: typeof raw.rule === 'string' ? raw.rule : undefined,
+        intentExamples: stringList('intentExamples'),
+        avoid: stringList('avoid'),
+        expectedOutcome: typeof raw.expectedOutcome === 'string' ? raw.expectedOutcome : undefined,
+    };
+}
 class DqlInternalRelationIdError extends Error {
     name = 'DqlInternalRelationIdError';
 }
@@ -15627,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 = [];
@@ -16068,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,
@@ -16094,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();
@@ -16118,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;
 }
@@ -21369,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,