@duckcodeailabs/dql-cli 1.8.1 → 1.8.2

package/dist/local-runtime.js

@@ -145,6 +145,7 @@ export function parseAgentRunRequestBody(body) {
     return {
         request: {
             question,
+            selectedEvidenceId: agentRunString(record.selectedEvidenceId),
             requestedMode,
             audience,
             intent: agentRunString(record.intent),
@@ -197,6 +198,10 @@ export function shouldSynthesizeAgentRunAnswer(governedAnswer) {
         return false;
     return true;
 }
+export function agentAnswerHasExecutionFailure(governedAnswer) {
+    return typeof governedAnswer.executionError === 'string'
+        && governedAnswer.executionError.trim().length > 0;
+}
 function businessNarrativeGaps(warnings) {
     const businessRelevant = (warnings ?? []).filter((warning) => !(/missing requested output column/i.test(warning)
         || /\bquery plan\b/i.test(warning)
@@ -280,16 +285,20 @@ function recordConversationTurn(store, threadId, run) {
         // Conversation persistence is additive; a failed write must not fail the run.
     }
 }
-function conversationTurnInputFromRun(run) {
+export function conversationTurnInputFromRun(run) {
     const artifact = run.artifacts.find((candidate) => candidate.kind === 'answer')
         ?? run.artifacts.find((candidate) => candidate.kind === 'research_run')
         ?? run.artifacts[0];
     const payload = agentRunRecord(artifact?.payload);
     const result = agentRunRecord(payload?.result);
     const columns = conversationResultColumns(result?.columns);
-    const rows = Array.isArray(result?.rows)
-        ? result.rows.filter((row) => Boolean(row && typeof row === 'object' && !Array.isArray(row))).slice(0, 8)
+    // The visual preview stays tiny, but member resolution needs a wider bounded
+    // value window. Deriving dimensions from only the eight preview rows caused a
+    // valid row 9/10 member to disappear before the next turn (AGT-012/E2E-010).
+    const memberRows = Array.isArray(result?.rows)
+        ? result.rows.filter((row) => Boolean(row && typeof row === 'object' && !Array.isArray(row))).slice(0, 24)
         : [];
+    const rows = memberRows.slice(0, 8);
     const rowsSample = rows.map((row) => columns.map((column) => row[column]));
     const contextPack = agentRunRecord(payload?.contextPack);
     const questionPlan = agentRunRecord(contextPack?.questionPlan);
@@ -313,7 +322,7 @@ function conversationTurnInputFromRun(run) {
             ? {
                 columns,
                 rowsSample,
-                dimensionValues: conversationDimensionValues(columns, rows),
+                dimensionValues: conversationDimensionValues(columns, memberRows),
                 measureColumns,
                 rowCount: typeof rowCountRaw === 'number' ? rowCountRaw : rows.length || undefined,
             }
@@ -1445,6 +1454,7 @@ export async function startLocalServer(opts) {
             || governedAnswer.sourceCertifiedBlock
             || governedAnswer.dqlArtifact?.kind === 'certified_block'));
         const isExploratory = Boolean(governedAnswer.exploratoryCandidate);
+        const isExecutionFailure = agentAnswerHasExecutionFailure(governedAnswer);
         const isGroundingGap = governedAnswer.kind === 'no_answer'
             && governedAnswer.refusalCode === 'grounding_gap'
             && !isExploratory;
@@ -1465,7 +1475,7 @@ export async function startLocalServer(opts) {
         const needsClarification = governedAnswer.kind === 'no_answer'
             && !isGroundingGap && !isProviderError && !isModelDeclined && !isPolicyBlocked;
         const sql = governedAnswer.proposedSql ?? governedAnswer.sql;
-        const runnableSql = governedAnswer.kind === 'no_answer' || (isExploratory && !governedAnswer.result)
+        const runnableSql = governedAnswer.kind === 'no_answer' || isExecutionFailure || (isExploratory && !governedAnswer.result)
             ? undefined
             : sql;
         // Render executed rows deterministically for ordinary lookups. A second LLM
@@ -1504,14 +1514,14 @@ export async function startLocalServer(opts) {
                 synthesizedAnswer = undefined;
             }
         }
-        const status = isProviderError
+        const status = isProviderError || isExecutionFailure
             ? 'blocked'
             : needsClarification
                 ? 'needs_clarification'
                 : isCertified || isSemantic
                     ? 'completed'
                     : 'needs_review';
-        const trustState = isProviderError
+        const trustState = isProviderError || isExecutionFailure
             ? 'blocked'
             : needsClarification
                 ? 'not_applicable'
@@ -1520,7 +1530,7 @@ export async function startLocalServer(opts) {
                     : isSemantic
                         ? 'governed'
                         : 'review_required';
-        const stopReason = isProviderError
+        const stopReason = isProviderError || isExecutionFailure
             ? 'blocked'
             : needsClarification
                 ? 'needs_clarification'
@@ -1531,33 +1541,41 @@ export async function startLocalServer(opts) {
                         : 'human_review_required';
         const nextActions = needsClarification
             ? [{ id: 'clarify', label: 'Clarify question', route: 'generated_answer' }]
-            : [
-                { id: 'create-block', label: governedAnswer.dqlArtifact ? 'Review DQL draft' : 'Create DQL draft', route: 'dql_block_draft', artifactKind: 'dql_block_draft' },
-                { id: 'research-gap', label: 'Research deeper', route: 'research' },
-                ...(runnableSql ? [{
-                        id: 'insert-sql',
-                        label: governedAnswer.dqlArtifact ? 'Insert as DQL cell' : 'Insert SQL preview',
-                        route: 'sql_cell',
-                        artifactKind: 'sql_cell',
-                    }] : []),
-            ];
+            : isExecutionFailure
+                ? [{ id: 'retry-after-connection', label: 'Retry after fixing the database connection', route: 'generated_answer' }]
+                : isGroundingGap
+                    ? [{ id: 'research-gap', label: 'Research missing metadata coverage', route: 'research', artifactKind: 'research_run' }]
+                    : [
+                        { id: 'create-block', label: governedAnswer.dqlArtifact ? 'Review DQL draft' : 'Create DQL draft', route: 'dql_block_draft', artifactKind: 'dql_block_draft' },
+                        { id: 'research-gap', label: 'Research deeper', route: 'research' },
+                        ...(runnableSql ? [{
+                                id: 'insert-sql',
+                                label: governedAnswer.dqlArtifact ? 'Insert as DQL cell' : 'Insert SQL preview',
+                                route: 'sql_cell',
+                                artifactKind: 'sql_cell',
+                            }] : []),
+                    ];
         return {
             resolvedRoute,
             answerRefusalCode: governedAnswer.kind === 'no_answer' ? governedAnswer.refusalCode : undefined,
             answerTier: governedAnswer.route?.tier,
-            summary: governedAnswer.route?.label ?? (isCertified ? 'Answered from certified DQL context.' : isExploratory ? 'Exploratory DBT-grounded analysis requires review.' : 'Answered with review-required generated analysis.'),
+            summary: isExecutionFailure
+                ? 'The governed query could not be executed.'
+                : governedAnswer.route?.label ?? (isCertified ? 'Answered from certified DQL context.' : isExploratory ? 'Exploratory DBT-grounded analysis requires review.' : 'Answered with review-required generated analysis.'),
             answer: synthesizedAnswer ?? governedAnswer.answer ?? governedAnswer.text,
             status,
             trustState,
             stopReason,
-            artifacts: governedAnswer.kind === 'no_answer'
-                // A refusal still keeps the DQL draft the answer loop produced (when any),
-                // so the "Review DQL draft" next-action isn't a dead link and the user can
-                // see the SQL that was about to run. Provider outages carry no draft.
-                ? (governedAnswer.dqlArtifact && !isProviderError
-                    ? [agentRunArtifact('dql_block_draft', 'DQL draft (review required)', governedAnswer.dqlArtifact, undefined, 'review_required')]
-                    : [])
-                : [agentRunArtifact('answer', isCertified ? 'Certified answer' : isSemantic ? 'Governed semantic answer' : isExploratory ? 'Exploratory DBT-grounded answer' : 'Review-required answer', governedAnswer, governedAnswer.sourceCertifiedBlock ?? governedAnswer.block?.name, isCertified ? 'certified' : isSemantic ? 'governed' : 'review_required')],
+            artifacts: isExecutionFailure
+                ? []
+                : governedAnswer.kind === 'no_answer'
+                    // A refusal still keeps the DQL draft the answer loop produced (when any),
+                    // so the "Review DQL draft" next-action isn't a dead link and the user can
+                    // see the SQL that was about to run. Provider outages carry no draft.
+                    ? (governedAnswer.dqlArtifact && !isProviderError && !isGroundingGap && !isModelDeclined && !isPolicyBlocked
+                        ? [agentRunArtifact('dql_block_draft', 'DQL draft (review required)', governedAnswer.dqlArtifact, undefined, 'review_required')]
+                        : [])
+                    : [agentRunArtifact('answer', isCertified ? 'Certified answer' : isSemantic ? 'Governed semantic answer' : isExploratory ? 'Exploratory DBT-grounded answer' : 'Review-required answer', governedAnswer, governedAnswer.sourceCertifiedBlock ?? governedAnswer.block?.name, isCertified ? 'certified' : isSemantic ? 'governed' : 'review_required')],
             evaluations: [
                 agentRunEvaluation('route-decision', 'Route decision', true, 'info', routeDecision?.reason ?? 'Routed request to governed answer.', {
                     plannedRoute: route,
@@ -1586,6 +1604,7 @@ export async function startLocalServer(opts) {
                                 : isExploratory
                                     ? 'The answer used bounded DBT/schema evidence because no certified modeled relationship path covered the request. It is review-required and was not certified.'
                                     : 'The answer is generated or semantic-layer backed and remains review-required.', governedAnswer.route),
+                ...(isExecutionFailure ? [agentRunEvaluation('query-execution', 'Query execution', false, 'blocking', `The governed query failed before it produced a result: ${governedAnswer.executionError}`)] : []),
                 ...(isGroundingGap ? [
                     {
                         ...agentRunEvaluation('grounding-gap', 'Metadata grounding', false, 'warning', 'The bounded lookup could not prove the required metadata grounding. No automatic retry or Research escalation was started.', {
@@ -2171,6 +2190,7 @@ export async function startLocalServer(opts) {
             : undefined;
         const task = buildLocalContextPack(projectRoot, {
             question: request.question,
+            focusObjectKey: request.selectedEvidenceId,
             followUp,
             priorContextPackId: agentRunString(request.conversationContext?.contextPackId),
             conversationTopicRelation: topicRelation === 'continuation'
@@ -2246,9 +2266,9 @@ export async function startLocalServer(opts) {
                     };
                 }
                 if ((candidate.kind === 'semantic_metric' || candidate.kind === 'semantic_member')
-                    && semanticEvidence.has(candidate.id)
-                    && pack.routeDecision.route !== 'clarify'
-                    && pack.routeDecision.route !== 'conflict') {
+                    && (semanticEvidence.has(candidate.id) || request.selectedEvidenceId === candidate.id)
+                    && (request.selectedEvidenceId === candidate.id
+                        || (pack.routeDecision.route !== 'clarify' && pack.routeDecision.route !== 'conflict'))) {
                     const requestedDimensions = pack.questionPlan.requestedShape.dimensions.map((dimension) => dimension.toLowerCase());
                     const availableDimensions = (candidate.dimensions ?? []).map((dimension) => dimension.toLowerCase());
                     const dimensionsFit = requestedDimensions.length === 0 || requestedDimensions.every((requested) => availableDimensions.some((available) => available === requested || available.endsWith(`.${requested}`)));
@@ -8722,6 +8742,12 @@ export async function startLocalServer(opts) {
                 }));
                 return;
             }
+            const provider = semanticConfig?.provider ?? semanticDetectedProvider ?? 'dql';
+            const dbtManifestReady = provider === 'dbt'
+                ? hasDbtSemanticManifest(projectRoot, semanticConfig?.projectPath)
+                : false;
+            const metricFlowReady = provider === 'dbt' ? hasMetricFlowCli() : false;
+            const dbtExecutionReady = dbtManifestReady && metricFlowReady;
             const metrics = semanticLayer.listMetrics().map((m) => ({
                 name: m.name,
                 label: m.label,
@@ -8736,6 +8762,7 @@ export async function startLocalServer(opts) {
                 typeParams: m.typeParams ?? null,
                 filter: m.filter ?? null,
                 source: m.source ?? null,
+                execution: semanticMetricExecutionCapability(m.name, semanticLayer, provider, metricFlowReady, connection?.driver),
             }));
             const measures = semanticLayer.listMeasures().map((m) => ({
                 name: m.name,
@@ -8833,12 +8860,6 @@ export async function startLocalServer(opts) {
                 owner: q.owner ?? null,
                 source: q.source ?? null,
             }));
-            const provider = semanticConfig?.provider ?? semanticDetectedProvider ?? 'dql';
-            const dbtManifestReady = provider === 'dbt'
-                ? hasDbtSemanticManifest(projectRoot, semanticConfig?.projectPath)
-                : false;
-            const metricFlowReady = provider === 'dbt' ? hasMetricFlowCli() : false;
-            const dbtExecutionReady = dbtManifestReady && metricFlowReady;
             const dbtExecutionSetup = dbtExecutionReady
                 ? null
                 : !dbtManifestReady && !metricFlowReady
@@ -9753,8 +9774,20 @@ export async function startLocalServer(opts) {
                     tableMapping,
                 });
                 if (!composed) {
+                    const provider = semanticConfig?.provider ?? semanticDetectedProvider ?? 'dql';
+                    const metricFlowReady = provider === 'dbt' && hasMetricFlowCli();
+                    const blocked = metrics.map((metricName) => ({
+                        metric: metricName,
+                        ...semanticMetricExecutionCapability(metricName, semanticLayer, provider, metricFlowReady, driver),
+                    })).filter((capability) => capability.status !== 'ready');
                     res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
-                    res.end(serializeJSON({ error: `Could not compose query for metrics: [${metrics.join(', ')}]` }));
+                    res.end(serializeJSON({
+                        error: blocked.length > 0
+                            ? blocked.map((capability) => `${capability.metric}: ${capability.reason}`).join(' ')
+                            : 'The selected dimensions do not share a governed join path with every selected metric.',
+                        code: blocked.length > 0 ? 'SEMANTIC_RUNTIME_REQUIRED' : 'SEMANTIC_FIELDS_INCOMPATIBLE',
+                        details: { metrics, dimensions, blocked },
+                    }));
                     return;
                 }
                 // Execute the composed SQL against the resolved connection
@@ -9839,8 +9872,20 @@ export async function startLocalServer(opts) {
                     tableMapping,
                 });
                 if (!composed) {
+                    const provider = semanticConfig?.provider ?? semanticDetectedProvider ?? 'dql';
+                    const metricFlowReady = provider === 'dbt' && hasMetricFlowCli();
+                    const blocked = metrics.map((metricName) => ({
+                        metric: metricName,
+                        ...semanticMetricExecutionCapability(metricName, semanticLayer, provider, metricFlowReady, driver),
+                    })).filter((capability) => capability.status !== 'ready');
                     res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
-                    res.end(serializeJSON({ error: 'Could not compose semantic block preview SQL.' }));
+                    res.end(serializeJSON({
+                        error: blocked.length > 0
+                            ? blocked.map((capability) => `${capability.metric}: ${capability.reason}`).join(' ')
+                            : 'The selected dimensions do not share a governed join path with every selected metric.',
+                        code: blocked.length > 0 ? 'SEMANTIC_RUNTIME_REQUIRED' : 'SEMANTIC_FIELDS_INCOMPATIBLE',
+                        details: { metrics, dimensions, blocked },
+                    }));
                     return;
                 }
                 const prepared = prepareLocalExecution(composed.sql, targetConnection, projectRoot, projectConfig);
@@ -13671,6 +13716,28 @@ export function openBlockStudioDocument(projectRoot, relativePath, semanticLayer
         validation: validateBlockStudioSource(source, semanticLayer),
     };
 }
+function semanticMetricExecutionCapability(metricName, semanticLayer, provider, metricFlowReady, driver) {
+    if (provider === 'dbt' && metricFlowReady) {
+        return { status: 'ready', engine: 'metricflow', reason: null };
+    }
+    const native = semanticLayer.composeQuery({ metrics: [metricName], dimensions: [], driver });
+    if (native)
+        return { status: 'ready', engine: 'native', reason: null };
+    const metric = semanticLayer.getMetric(metricName);
+    if (provider === 'dbt') {
+        const kind = metric?.metricType || metric?.aggregation || metric?.type || 'metric';
+        return {
+            status: 'requires_setup',
+            engine: null,
+            reason: `${kind} metric requires MetricFlow execution. Install/configure the MetricFlow CLI, then refresh the semantic layer.`,
+        };
+    }
+    return {
+        status: 'unsupported',
+        engine: null,
+        reason: 'The metric does not have enough composable measure and relation metadata.',
+    };
+}
 function parseBlockStudioArrayField(source, key) {
     const match = source.match(new RegExp(`\\b${key}\\s*=\\s*\\[([\\s\\S]*?)\\]`, 'i'));
     if (!match)
@@ -13905,10 +13972,18 @@ function composeSemanticBlockSql(source, semanticLayer, options) {
         return { sql: null, diagnostics, semanticRefs };
     }
     if (!composed) {
+        const provider = options?.projectConfig && isDbtSemanticRuntime(options.projectConfig, options.detectedProvider, semanticLayer) ? 'dbt' : (options?.detectedProvider ?? 'dql');
+        const metricFlowReady = provider === 'dbt' && hasMetricFlowCli();
+        const reasons = metrics.map((metricName) => {
+            const capability = semanticMetricExecutionCapability(metricName, semanticLayer, provider, metricFlowReady, options?.driver);
+            return capability.status === 'ready' ? null : `${metricName}: ${capability.reason}`;
+        }).filter((reason) => Boolean(reason));
         diagnostics.push({
             severity: 'error',
             code: 'semantic_compose_failed',
-            message: `Could not compose SQL for semantic block metrics: [${metrics.join(', ')}].`,
+            message: reasons.length > 0
+                ? `Could not compose SQL for semantic block metrics. ${reasons.join(' ')}`
+                : `Could not compose SQL for semantic block metrics: [${metrics.join(', ')}]. Check that the selected dimensions share a governed join path.`,
         });
         return { sql: null, diagnostics, semanticRefs };
     }