@duckcodeailabs/dql-cli 1.11.0 → 1.11.2

package/dist/local-runtime.js

@@ -10,7 +10,7 @@ import { Readable } from "node:stream";
 import { buildMixedSourceWarehouseFallbackSql, findMentionedNotebookDataset, planMixedSourceNotebookSql, planMixedSourceSql, } from "./mixed-source-sql.js";
 import { resolveNpmInvocation } from './npm-runtime.js';
 import { buildExecutionPlan, createWelcomeNotebook, deserializeNotebook, getConnectorFormSchemas, hasSemanticRefs, hasStandaloneSemanticRef, resolveSemanticRefs, } from '@duckcodeailabs/dql-notebook';
-import { loadSemanticLayerFromDir, normalizeDqlArtifactReference, serializeMetricDefinitionToYaml, resolveSemanticLayerAsync, resolveRepoSource, getDialect, Parser, NodeKind, blockParameterDefinitions, buildLineageGraph, buildManifest, collectInputFiles, findAppDocuments, findDashboardsForApp, isBlockIdRef, loadAppDocument, loadDashboardDocument, analyzeImpact, buildTrustChain, detectDomainFlows, getDomainTrustOverview, queryLineage, queryBusiness360, queryCompleteLineagePaths, LineageGraph, canonicalize, canonicalizeNotebook, diffDQL, diffNotebook, domainFolderSlug, previewModelingChange, applyModelingChange, previewDbtSourcePatch, applyDbtSourcePatch, loadDomainPackageRegistry, loadDbtNodeAuthoringDetail, normalizeAnalyticalFailureV1, relationshipValidationProofFingerprint, discoverDbtDomains, renderDomainDeclaration, ProjectSnapshotService, analyzeSqlReferences, semanticDimensionReference, } from '@duckcodeailabs/dql-core';
+import { loadSemanticLayerFromDir, normalizeDqlArtifactReference, serializeMetricDefinitionToYaml, resolveSemanticLayerAsync, resolveRepoSource, getDialect, Parser, NodeKind, blockParameterDefinitions, buildLineageGraph, buildManifest, collectInputFiles, findAppDocuments, findDashboardsForApp, isBlockIdRef, loadAppDocument, loadDashboardDocument, analyzeImpact, buildTrustChain, detectDomainFlows, getDomainTrustOverview, queryLineage, queryBusiness360, queryCompleteLineagePaths, LineageGraph, canonicalize, canonicalizeNotebook, diffDQL, diffNotebook, domainFolderSlug, previewModelingChange, applyModelingChange, previewDbtSourcePatch, applyDbtSourcePatch, loadDomainPackageRegistry, loadDbtNodeAuthoringDetail, normalizeAnalyticalFailureV1, relationshipValidationProofFingerprint, renderSemanticBlockSource, discoverDbtDomains, renderDomainDeclaration, ProjectSnapshotService, analyzeSqlReferences, semanticDimensionReference, } from '@duckcodeailabs/dql-core';
 import { load as loadYaml } from 'js-yaml';
 import { listBlockTemplates } from './block-templates.js';
 import { getRunner as getLLMRunner } from './llm/index.js';
@@ -96,6 +96,16 @@ function agentRunRecord(value) {
 function agentRunString(value) {
     return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
 }
+/** UI catalog fallback labels are not declared project domains. */
+export function normalizeAgentRunDomain(value) {
+    const domain = agentRunString(value);
+    if (!domain)
+        return undefined;
+    const normalized = domain.toLowerCase();
+    return normalized === 'uncategorized' || normalized === '_uncategorized'
+        ? undefined
+        : domain;
+}
 function parseAgentRunRequestedMode(value) {
     return typeof value === 'string' && AGENT_RUN_REQUESTED_MODES.has(value)
         ? value
@@ -1081,12 +1091,13 @@ export async function startLocalServer(opts) {
      */
     const buildDirectBuildContext = async (input) => {
         const snapshot = projectSnapshot();
+        const activeDomain = normalizeAgentRunDomain(input.domain);
         const domainContext = resolveDomainContextEnvelope({
             manifest: snapshot.manifest,
-            activeDomain: input.domain,
+            activeDomain,
             purpose: input.purpose,
             modelAreaId: input.modelAreaId,
-            source: input.domain ? 'explicit_ui' : 'inferred',
+            source: activeDomain ? 'explicit_ui' : 'inferred',
             snapshotId: snapshot.snapshotId,
         });
         const contextPack = await buildLocalContextPack(projectRoot, {
@@ -1095,7 +1106,7 @@ export async function startLocalServer(opts) {
             surface: input.surface,
             selectedContext: {
                 activeSurface: input.surface,
-                domain: input.domain,
+                domain: activeDomain,
                 purpose: input.purpose,
                 modelAreaId: input.modelAreaId,
                 ...input.selectedContext,
@@ -1249,7 +1260,7 @@ export async function startLocalServer(opts) {
         const semanticTableMapping = semanticLayer && semanticConnection
             ? await resolveSemanticTableMapping(executor, semanticConnection, semanticLayer)
             : undefined;
-        const requestedDomain = agentRunWorkspaceValue(request, 'domain');
+        const requestedDomain = normalizeAgentRunDomain(agentRunWorkspaceValue(request, 'domain'));
         const requestedPurpose = agentRunWorkspaceValue(request, 'purpose');
         const requestedModelAreaId = agentRunWorkspaceValue(request, 'modelAreaId');
         const runProjectSnapshot = projectSnapshot();
@@ -1800,6 +1811,20 @@ export async function startLocalServer(opts) {
                 status: 'blocked',
                 trustState: 'blocked',
                 stopReason: 'blocked',
+                artifacts: [agentRunArtifact('answer', 'AI answer provider failed', {
+                        kind: 'no_answer',
+                        refusalCode: 'provider_error',
+                        text: message,
+                        answer: message,
+                        ...(routeDecision?.resolvedAnalyticalPlan
+                            ? { resolvedAnalyticalPlan: routeDecision.resolvedAnalyticalPlan }
+                            : {}),
+                        providerFailure: {
+                            code: 'AI_PROVIDER_FAILURE',
+                            message,
+                            recoverable: true,
+                        },
+                    }, undefined, 'blocked')],
                 evaluations: [
                     agentRunEvaluation('route-decision', 'Route decision', true, 'info', routeDecision?.reason ?? 'Routed request to governed answer.'),
                     agentRunEvaluation('ai-provider', 'AI provider', false, 'blocking', message, { originalErrorType: error instanceof Error ? error.name : typeof error }),
@@ -1825,12 +1850,12 @@ export async function startLocalServer(opts) {
             && !isExploratory;
         const isProviderError = governedAnswer.kind === 'no_answer' && governedAnswer.refusalCode === 'provider_error';
         const isAnalyticalFailure = Boolean(governedAnswer.analyticalFailure);
-        const isTerminalFailure = isProviderError || isExecutionFailure || isAnalyticalFailure;
         // AGT-004: a rejected attribution/export/proof policy is a deliberate
         // governance boundary, not an ambiguous user question and not a repairable
         // retrieval miss. Keep the precise policy detail visible, but never burn two
         // more provider calls retrying the same incompatible candidate.
         const isPolicyBlocked = governedAnswer.kind === 'no_answer' && governedAnswer.refusalCode === 'policy_blocked';
+        const isTerminalFailure = isProviderError || isExecutionFailure || isAnalyticalFailure || isPolicyBlocked;
         // The model tried to compose a governed query and declined despite having usable
         // context (e.g. it wasn't confident about a multi-table join). The answer loop
         // has already spent its one evidence-aware repair. Keep this terminal and
@@ -1922,7 +1947,16 @@ export async function startLocalServer(opts) {
                         : [{ id: 'review-analytical-failure', label: 'Review the plan, DQL, SQL, and safe repair actions', route: 'blocked' }]
             : isProviderError
                 ? [{ id: 'retry-after-provider', label: 'Retry after fixing the AI provider', route: 'generated_answer' }]
-                : [{ id: 'retry-after-connection', label: 'Retry after fixing the database connection', route: 'generated_answer' }];
+                : isPolicyBlocked
+                    ? [
+                        ...(governedAnswer.dqlArtifact
+                            ? [{ id: 'edit_dql', label: 'Open DQL to repair', route: 'dql_block_draft', artifactKind: 'dql_block_draft' }]
+                            : []),
+                        ...(sql
+                            ? [{ id: 'open_sql_notebook', label: 'Open SQL in Notebook', route: 'sql_cell', artifactKind: 'sql_cell' }]
+                            : []),
+                    ]
+                    : [{ id: 'retry-after-connection', label: 'Retry after fixing the database connection', route: 'generated_answer' }];
         const nextActions = needsClarification
             ? [{ id: 'clarify', label: 'Clarify question', route: 'generated_answer' }]
             : isTerminalFailure
@@ -1944,7 +1978,11 @@ export async function startLocalServer(opts) {
             answerRefusalCode: governedAnswer.kind === 'no_answer' ? governedAnswer.refusalCode : undefined,
             answerTier: governedAnswer.route?.tier,
             summary: isTerminalFailure
-                ? 'The governed query could not be executed.'
+                ? governedAnswer.analyticalFailure?.message
+                    ?? governedAnswer.executionError
+                    ?? governedAnswer.answer
+                    ?? governedAnswer.text
+                    ?? '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,
             ...(governedAnswer.clarificationOptions?.length
@@ -2373,87 +2411,88 @@ export async function startLocalServer(opts) {
                 ],
             };
         },
-        dql_block_draft: async ({ request, routeDecision, attempt, repairHint }) => {
+        dql_block_draft: async ({ request, routeDecision, attempt, repairHint, emit, runId, maxRepairAttempts, }) => {
             const contextRecord = agentRunRecord(request.conversationContext);
             const carriedDqlArtifact = normalizeDqlArtifactReference(contextRecord?.dqlArtifact)
                 ?? normalizeDqlArtifactReference(request.workspaceContext?.dqlArtifact);
-            if (carriedDqlArtifact && (attempt ?? 0) === 0) {
-                const sourceQuestion = agentRunString(contextRecord?.sourceQuestion) ?? request.question;
-                const session = await createDqlArtifactGenerationSessionForProject(projectRoot, {
-                    question: sourceQuestion,
-                    dqlArtifact: carriedDqlArtifact,
-                    inputMode: 'upload',
-                    inputPath: carriedDqlArtifact.sourcePath,
-                    domain: agentRunWorkspaceValue(request, 'domain'),
-                    owner: agentRunWorkspaceValue(request, 'owner'),
-                    tags: ['agent-run', 'review-required'],
-                    contextPackId: agentRunString(contextRecord?.contextPackId),
-                    routeIntent: agentRunString(contextRecord?.route),
-                    sourceBlock: carriedDqlArtifact.sourcePath,
-                }, semanticLayer);
-                const candidate = session.candidates[0];
-                const validation = candidate?.validation && typeof candidate.validation === 'object'
-                    ? candidate.validation
-                    : undefined;
-                const ready = validation?.valid !== false;
-                const payload = {
-                    target: 'block',
-                    name: candidate?.name ?? carriedDqlArtifact.name ?? 'DQL block draft',
-                    path: candidate?.draftSave?.path ?? candidate?.savedPath,
-                    importId: session.id,
-                    candidateId: candidate?.id,
-                    source: candidate?.dqlSource,
-                    dqlSource: candidate?.dqlSource,
-                    dqlArtifact: carriedDqlArtifact,
-                    certifierVerdict: {
-                        ready,
-                        diagnostics: validation?.diagnostics ?? [],
-                    },
-                    generation: session.generation,
-                };
-                return {
-                    summary: ready
-                        ? 'Saved the generated DQL artifact as a review-required block draft.'
-                        : 'Saved the generated DQL artifact as a block draft with review blockers or warnings.',
-                    artifacts: [agentRunArtifact('dql_block_draft', payload.name, payload, payload.path)],
+            // UI-016 / E2E-015: a cold Block AI request uses the same governed answer
+            // pipeline as Ask and Notebook. Generation is write-free. The returned
+            // ownerless artifact is persisted only when the user explicitly chooses
+            // Add to Block Studio.
+            const governedResult = carriedDqlArtifact && (attempt ?? 0) === 0
+                ? {
+                    summary: 'Reused the governed answer artifact as a transient Block AI draft.',
+                    answer: 'Prepared the existing governed DQL as an ownerless review draft. No file was changed.',
+                    artifacts: [agentRunArtifact('answer', carriedDqlArtifact.name ?? 'Governed DQL answer', { dqlArtifact: carriedDqlArtifact }, undefined, carriedDqlArtifact.trustState)],
                     evaluations: [
-                        agentRunEvaluation('route-decision', 'Route decision', true, 'info', routeDecision?.reason ?? 'Routed request to DQL block draft generation.'),
-                        agentRunEvaluation('dql-artifact-reuse', 'Used generated DQL artifact', true, 'info', 'Persisted the existing DQL artifact without regenerating it from SQL.', { importId: session.id, path: payload.path }),
-                        agentRunEvaluation('certification-boundary', 'Certification boundary', ready, 'warning', ready
-                            ? 'The draft has no automatic validation blockers, but certification still requires human review.'
-                            : 'The draft has validation blockers that must be resolved before certification review.', payload),
-                    ],
-                    nextActions: [
-                        { id: 'open-review', label: 'Open review checklist', artifactKind: 'dql_block_draft' },
-                        { id: 'build-app', label: 'Build app from block', route: 'app_build', artifactKind: 'app_draft' },
+                        agentRunEvaluation('dql-artifact-reuse', 'Reused governed DQL artifact', true, 'info', 'Reused the exact answer artifact without regenerating SQL or writing a block file.'),
                     ],
-                };
+                }
+                : await answerRunExecutor({
+                    request,
+                    route: 'generated_answer',
+                    routeDecision,
+                    attempt,
+                    repairHint,
+                    emit,
+                    runId,
+                    maxRepairAttempts,
+                });
+            if (governedResult.status === 'blocked' || governedResult.status === 'needs_clarification') {
+                return governedResult;
+            }
+            const governedPayload = (governedResult.artifacts ?? [])
+                .map((artifact) => agentRunRecord(artifact.payload))
+                .find((payload) => Boolean(normalizeDqlArtifactReference(payload?.dqlArtifact)
+                ?? normalizeDqlArtifactReference(payload)));
+            const directDqlArtifact = normalizeDqlArtifactReference(governedPayload);
+            const governedAnswer = governedPayload
+                ? directDqlArtifact
+                    ? { dqlArtifact: directDqlArtifact }
+                    : governedPayload
+                : undefined;
+            const dqlArtifact = governedAnswer
+                ? ownerlessReviewDqlArtifactFromAnswer(governedAnswer, request.question)
+                : undefined;
+            if (!dqlArtifact) {
+                return governedResult;
             }
-            // P4 (partial): a direct "build a block from a cold prompt" still uses the
-            // tool-less buildFromPrompt path. Unlike a SQL cell, a block needs SQL→DQL-block
-            // CONSTRUCTION (name, outputs, grain, certifier verdict, reflection), which
-            // buildFromPrompt owns — routing this through answer() cleanly requires driving
-            // that construction from the tool-rich pipeline (thread captureGeneratedDraft
-            // through the governed answer), a larger change deferred to its own session.
-            // NOTE: the two-step "ask a question → Create DQL draft" flow ALREADY routes
-            // block creation through the tool-rich governed pipeline via the carried-artifact
-            // branch above, so only this cold-start direct-build case remains tool-less.
-            const result = await buildAgentPromptArtifact(request, 'block', { attempt, repairHint });
-            const ready = result.target === 'block' ? result.certifierVerdict.ready : false;
+            const sql = dqlArtifact.compiledSql
+                ?? agentRunString(governedPayload?.proposedSql)
+                ?? agentRunString(governedPayload?.sql);
+            const result = {
+                target: 'block',
+                name: dqlArtifact.name ?? deriveGeneratedDraftSlug(request.question),
+                source: dqlArtifact.source,
+                dqlSource: dqlArtifact.source,
+                dqlArtifact,
+                ...(sql ? { sql, sqlPreview: sql } : {}),
+                ...(governedPayload?.result ? { result: governedPayload.result } : {}),
+                description: request.question,
+                dimensions: dqlArtifact.dimensions ?? [],
+                outputs: [...(dqlArtifact.dimensions ?? []), ...(dqlArtifact.metrics ?? [])],
+                certifierVerdict: {
+                    ready: true,
+                    blocking: [],
+                    warnings: [
+                        'Ownership is intentionally absent from the AI draft and is assigned by a human during promotion.',
+                        'Review the generated DQL, compiled SQL, grain, and result before promotion.',
+                    ],
+                },
+            };
             return {
-                summary: ready
-                    ? 'Created a DQL block draft that is ready for human certification review.'
-                    : 'Created a DQL block draft with review blockers or warnings.',
-                artifacts: [agentRunArtifact('dql_block_draft', result.target === 'block' ? result.name : 'DQL block draft', result, result.target === 'block' ? result.path : undefined)],
+                summary: 'Prepared an ownerless, review-required DQL block draft. No file was changed.',
+                answer: governedResult.answer,
+                status: 'needs_review',
+                trustState: 'review_required',
+                stopReason: 'human_review_required',
+                artifacts: [agentRunArtifact('dql_block_draft', result.name, result, undefined, 'review_required')],
                 evaluations: [
-                    agentRunEvaluation('route-decision', 'Route decision', true, 'info', routeDecision?.reason ?? 'Routed request to DQL block draft generation.'),
-                    agentRunEvaluation('certification-boundary', 'Certification boundary', ready, 'warning', ready
-                        ? 'The draft has no automatic certifier blockers, but certification still requires human review.'
-                        : 'The draft has certifier blockers that must be resolved before certification review.', result),
+                    ...(governedResult.evaluations ?? []),
+                    agentRunEvaluation('block-commit-boundary', 'Explicit Block Studio commit', true, 'warning', 'Generation produced an ownerless transient DQL artifact. Add to Block Studio is the only action that writes the review draft.', result),
                 ],
                 nextActions: [
-                    { id: 'open-review', label: 'Open review checklist', artifactKind: 'dql_block_draft' },
-                    { id: 'build-app', label: 'Build app from block', route: 'app_build', artifactKind: 'app_draft' },
+                    { id: 'add-to-block-studio', label: 'Add to Block Studio', artifactKind: 'dql_block_draft' },
                 ],
             };
         },
@@ -2566,7 +2605,7 @@ export async function startLocalServer(opts) {
         if (pending)
             return pending;
         const snapshot = projectSnapshot();
-        const requestedDomain = agentRunWorkspaceValue(request, 'domain');
+        const requestedDomain = normalizeAgentRunDomain(agentRunWorkspaceValue(request, 'domain'));
         // CTX-003: resolve result entities/values before evidence retrieval. The
         // router, planner, and answer loop must rank the same typed follow-up; doing
         // this only inside the provider adapter allowed stale catalog matches to win
@@ -15177,7 +15216,7 @@ function composeSemanticBlockSql(source, semanticLayer, options) {
         diagnostics.push({
             severity: 'error',
             code: 'semantic_metric_missing',
-            message: 'Semantic block is missing a metric. Add metric = "metric_name" or metrics = ["metric_name"].',
+            message: 'Semantic block is missing a metric. Add metrics = ["metric_name"].',
         });
         return { sql: null, diagnostics, semanticRefs };
     }
@@ -15203,12 +15242,9 @@ function composeSemanticBlockSql(source, semanticLayer, options) {
     if (diagnostics.some((diagnostic) => diagnostic.severity === 'error')) {
         return { sql: null, diagnostics, semanticRefs };
     }
-    // Import-adapter shape: a semantic block may carry a pre-compiled `query` (the
-    // governed metric already expanded to runnable SQL). When present, RUN THAT —
-    // the `metric` field is provenance/governance, not something to recompile. This
-    // keeps metric-bound blocks runnable offline (the full MetricFlow engine may be
-    // unavailable). We still validated the metric exists above. Returning the query
-    // as the composed SQL lets the normal {{ ref() }} resolution + execution apply.
+    // Legacy import-adapter compatibility: older semantic blocks may carry a
+    // pre-compiled `query`. Current writers keep compiled SQL outside semantic DQL,
+    // but existing files remain executable while they are migrated by the formatter.
     const precompiledQuery = extractBlockStudioSql(source);
     if (precompiledQuery) {
         return { sql: precompiledQuery, diagnostics, semanticRefs };
@@ -15890,7 +15926,96 @@ function saveDqlGenerationDraftForProject(projectRoot, importId, candidate) {
 }
 /** AI may propose block logic, but ownership is assigned by a human at promotion. */
 export function sanitizeAgentBlockDraftSource(source) {
-    return source.replace(/^(\s*owner\s*=\s*).+$/mi, '$1""');
+    return source.replace(/^\s*owner\s*=\s*.+(?:\r?\n|$)/gmi, '');
+}
+/**
+ * UI-016 / CONTRACT-002 / AGT-021 — derive the transient Block AI artifact
+ * from the exact governed answer artifact. Semantic drafts are re-rendered
+ * through the one canonical metrics/dimensions writer; custom SQL drafts retain
+ * their query body. Both become ownerless, review-required drafts and never
+ * inherit a saved/certified identity from their answer source.
+ */
+export function ownerlessReviewDqlArtifactFromAnswer(answer, question) {
+    const artifact = normalizeDqlArtifactReference(answer.result?.dqlArtifact)
+        ?? normalizeDqlArtifactReference(answer.dqlArtifact);
+    if (!artifact?.source)
+        return undefined;
+    const parsed = parseSemanticBlockConfig(artifact.source);
+    const metrics = Array.from(new Set([
+        ...(artifact.metrics ?? []),
+        ...parsed.metrics,
+        ...(parsed.metric ? [parsed.metric] : []),
+    ].map((metric) => metric.trim()).filter(Boolean)));
+    const dimensions = Array.from(new Set([
+        ...(artifact.dimensions ?? []),
+        ...parsed.dimensions,
+    ].map((dimension) => dimension.trim()).filter(Boolean)));
+    const name = artifact.name
+        ?? artifact.source.match(/\bblock\s+"([^"]+)"/i)?.[1]
+        ?? deriveGeneratedDraftSlug(question);
+    const compiledSql = artifact.compiledSql
+        ?? answer.result?.sql
+        ?? answer.proposedSql
+        ?? answer.sql;
+    if (artifact.kind === 'semantic_block' || parsed.blockType === 'semantic' || metrics.length > 0) {
+        const source = renderSemanticBlockSource({
+            name,
+            status: 'draft',
+            domain: parseBlockStudioStringField(artifact.source, 'domain'),
+            description: question,
+            tags: ['ai-generated', 'review-required'],
+            metrics,
+            dimensions,
+            timeDimension: artifact.timeDimension ?? (parsed.timeDimension && parsed.granularity
+                ? { name: parsed.timeDimension, granularity: parsed.granularity }
+                : undefined),
+            requestedFilters: (artifact.filters ?? parsed.filters).flatMap((filter) => filter.values.length > 0
+                ? filter.values.map((value) => `${filter.dimension}=${value}`)
+                : [filter.dimension]),
+            orderBy: artifact.orderBy,
+            limit: artifact.limit ?? parsed.limit,
+            parameters: artifact.parameters?.map((parameter) => ({
+                name: parameter.name,
+                type: parameter.type,
+                default: parameter.default,
+                policy: parameter.policy,
+                binding: parameter.binding?.kind === 'semantic_filter'
+                    ? parameter.binding.field
+                    : parameter.binding?.kind === 'limit'
+                        ? 'limit'
+                        : undefined,
+            })),
+            visualization: metrics.length > 1 ? { chart: 'table' } : undefined,
+        });
+        return {
+            ...artifact,
+            kind: 'semantic_block',
+            name,
+            source,
+            sourcePath: undefined,
+            metrics,
+            dimensions,
+            persistence: 'transient',
+            trustState: 'review_required',
+            ...(compiledSql ? { compiledSql } : {}),
+        };
+    }
+    let source = sanitizeAgentBlockDraftSource(artifact.source);
+    if (/\bstatus\s*=\s*"[^"]*"/i.test(source)) {
+        source = source.replace(/\bstatus\s*=\s*"[^"]*"/i, 'status = "draft"');
+    }
+    else {
+        source = source.replace(/(\bblock\s+"[^"]+"\s*\{)/i, '$1\n  status = "draft"');
+    }
+    return {
+        ...artifact,
+        name,
+        source,
+        sourcePath: undefined,
+        persistence: 'transient',
+        trustState: 'review_required',
+        ...(compiledSql ? { compiledSql } : {}),
+    };
 }
 export function saveBlockStudioArtifacts(projectRoot, options) {
     const slug = options.name.toLowerCase().replace(/[^a-z0-9_]+/g, '-').replace(/^[-_]+|[-_]+$/g, '') || 'block';
@@ -16656,29 +16781,18 @@ function buildSemanticImportCandidateSource(candidate, patch, semanticLayer) {
     const allowedFilters = (patch.allowedFilters ?? [])
         .map((filter) => compatibleByName.get(normalizedTerm(filter))?.name)
         .filter((filter) => Boolean(filter));
-    const quote = (value) => `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
-    const metricLine = metricNames.length === 1
-        ? `  metric = ${quote(metricNames[0])}`
-        : `  metrics = [${metricNames.map(quote).join(', ')}]`;
-    const lines = [
-        `block ${quote(candidate.name)} {`,
-        '  status = "draft"',
-        `  domain = ${quote(candidate.domain)}`,
-        '  type = "semantic"',
-        `  description = ${quote(candidate.description)}`,
-        `  owner = ${quote(candidate.owner)}`,
-        `  tags = [${candidate.tags.map(quote).join(', ')}]`,
-        metricLine,
-        dimensionNames.length > 0 ? `  dimensions = [${dimensionNames.map(quote).join(', ')}]` : '',
-        allowedFilters.length > 0 ? `  requested_filters = [${allowedFilters.map(quote).join(', ')}]` : '',
-        '',
-        '  visualization {',
-        `    chart = "${dimensionNames.length > 0 ? 'bar' : 'kpi'}"`,
-        '  }',
-        '}',
-        '',
-    ];
-    return lines.filter((line, index) => line !== '' || (index > 0 && lines[index - 1] !== '')).join('\n');
+    return renderSemanticBlockSource({
+        name: candidate.name,
+        status: 'draft',
+        domain: candidate.domain,
+        description: candidate.description,
+        owner: candidate.owner,
+        tags: candidate.tags,
+        metrics: metricNames,
+        dimensions: dimensionNames,
+        requestedFilters: allowedFilters,
+        visualization: { chart: dimensionNames.length > 0 ? 'bar' : 'kpi' },
+    });
 }
 function inferDqlGenerationTerms(evidence) {
     return Array.from(new Set(evidence
@@ -17950,44 +18064,18 @@ export function createSemanticBuilderBlock(projectRoot, options) {
     };
 }
 function buildSemanticBlockContent(options) {
-    const lines = [
-        `block "${options.name}" {`,
-        `    domain = "${options.domain ?? 'uncategorized'}"`,
-        '    type = "semantic"',
-    ];
-    if (options.description)
-        lines.push(`    description = "${escapeDqlString(options.description)}"`);
-    if (options.owner)
-        lines.push(`    owner = "${escapeDqlString(options.owner)}"`);
-    if (options.tags && options.tags.length > 0) {
-        lines.push(`    tags = [${options.tags.map((tag) => `"${escapeDqlString(tag)}"`).join(', ')}]`);
-    }
-    if (options.metrics.length === 0) {
-        lines.push('    metric = ""');
-    }
-    else if (options.metrics.length === 1) {
-        lines.push(`    metric = "${escapeDqlString(options.metrics[0])}"`);
-    }
-    else {
-        lines.push(`    metrics = [${options.metrics.map((metric) => `"${escapeDqlString(metric)}"`).join(', ')}]`);
-    }
-    if (options.dimensions.length > 0) {
-        lines.push(`    dimensions = [${options.dimensions.map((dimension) => `"${escapeDqlString(dimension)}"`).join(', ')}]`);
-    }
-    else {
-        lines.push('    dimensions = []');
-    }
-    if (options.timeDimension) {
-        lines.push(`    time_dimension = "${escapeDqlString(options.timeDimension.name)}"`);
-        lines.push(`    granularity = "${escapeDqlString(options.timeDimension.granularity)}"`);
-    }
-    const visualization = buildVisualizationBlock(options.chart ?? 'table', options.dimensions, options.timeDimension, options.metrics);
-    if (visualization) {
-        lines.push('');
-        lines.push(...visualization);
-    }
-    lines.push('}');
-    return lines.join('\n') + '\n';
+    return renderSemanticBlockSource({
+        name: options.name,
+        status: 'draft',
+        domain: options.domain,
+        description: options.description,
+        owner: options.owner,
+        tags: options.tags,
+        metrics: options.metrics,
+        dimensions: options.dimensions,
+        timeDimension: options.timeDimension,
+        visualization: semanticBlockVisualization(options.chart ?? 'table', options.dimensions, options.timeDimension, options.metrics),
+    });
 }
 function buildCustomSemanticBlockContent(options) {
     const lines = [
@@ -18039,6 +18127,21 @@ function buildVisualizationBlock(chart, dimensions, timeDimension, metrics) {
         '    }',
     ];
 }
+function semanticBlockVisualization(chart, dimensions, timeDimension, metrics) {
+    if (metrics.length > 1)
+        return { chart: 'table' };
+    const x = timeDimension ? `${timeDimension.name}_${timeDimension.granularity}` : dimensions[0];
+    const y = metrics[0];
+    if (chart === 'table')
+        return { chart: 'table' };
+    if (chart === 'kpi')
+        return { chart: 'kpi', ...(y ? { y } : {}) };
+    return {
+        chart: x ? chart : 'table',
+        ...(x ? { x } : {}),
+        ...(x && y ? { y } : {}),
+    };
+}
 function writeBlockCompanionFile(projectRoot, options) {
     const extractedRefs = extractSemanticReferenceNames(options.content);
     const semanticMetrics = Array.from(new Set([...(options.semanticMetrics ?? []), ...extractedRefs.metrics]));
@@ -18227,23 +18330,17 @@ function buildBlankBlockContent(options) {
     return lines.join('\n') + '\n';
 }
 function buildBlankSemanticBlockContent(options) {
-    const lines = [
-        `block "${escapeDqlString(options.name)}" {`,
-        `    domain = "${escapeDqlString(options.domain)}"`,
-        '    type = "semantic"',
-        '    status = "draft"',
-        `    description = "${escapeDqlString(options.description?.trim() || options.name)}"`,
-        `    owner = "${escapeDqlString(options.owner?.trim() ?? '')}"`,
-        `    tags = [${(options.tags ?? []).map((tag) => `"${escapeDqlString(tag)}"`).join(', ')}]`,
-        '    metric = ""',
-        '    dimensions = []',
-        '',
-        '    visualization {',
-        '        chart = "table"',
-        '    }',
-        '}',
-    ];
-    return lines.join('\n') + '\n';
+    return renderSemanticBlockSource({
+        name: options.name,
+        status: 'draft',
+        domain: options.domain,
+        description: options.description?.trim() || options.name,
+        owner: options.owner,
+        tags: options.tags,
+        metrics: [],
+        dimensions: [],
+        visualization: { chart: 'table' },
+    });
 }
 function parseYamlScalar(value) {
     const trimmed = value.trim();