@duckcodeailabs/dql-cli 1.13.2 → 1.13.4

package/dist/local-runtime.js

@@ -48,6 +48,7 @@ import { buildSemanticTargetBinding } from './semantic-execution/target-binding.
 import { discoverWarehouseMetadataScopes, normalizeConnectionMetadataScope, syncWarehouseMetadata, warehouseMetadataStatus, } from './warehouse-metadata.js';
 import { NotebookDatasetWorkspace, } from "./notebook-datasets.js";
 import { prepareBlockInvocation } from './block-invocation.js';
+export const APP_SOURCE_REUSABLE_TAG = 'app-source';
 const NOTEBOOK_EXECUTE_PREVIEW_ROW_LIMIT = 500;
 const NOTEBOOK_FAVICON_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" rx="7" fill="#6d5dfc"/><path d="M9 9h14v14H9z" fill="none" stroke="#fff" stroke-width="2"/><path d="M13 13h6M13 17h6M13 21h4" stroke="#fff" stroke-width="2" stroke-linecap="round"/></svg>';
 export function resolveProjectSemanticConfig(projectConfig, projectRoot) {
@@ -968,6 +969,36 @@ export async function startLocalServer(opts) {
     // rather than treating compiled semantic SQL as unrelated generic SQL.
     const compiledSemanticQueries = new Map();
     const dashboardRunEvidence = new Map();
+    const loadAppBuildPreviewEvidence = (runId) => {
+        const memoryEvidence = dashboardRunEvidence.get(runId);
+        if (memoryEvidence && memoryEvidence.expiresAt >= Date.now())
+            return memoryEvidence;
+        if (memoryEvidence)
+            dashboardRunEvidence.delete(runId);
+        const storage = new LocalAppStorage(defaultLocalAppsDbPath(projectRoot));
+        try {
+            const persisted = storage.getAppPreviewEvidence(runId);
+            if (!persisted)
+                return null;
+            return {
+                appId: persisted.draftId,
+                dashboardId: persisted.dashboardId,
+                snapshotId: persisted.snapshotId,
+                filterFingerprint: persisted.filterFingerprint,
+                resultFingerprint: persisted.resultFingerprint,
+                personaFingerprint: persisted.personaFingerprint,
+                successfulTileIds: persisted.successfulTileIds,
+                semanticApprovalEligibleTileIds: persisted.semanticApprovalEligibleTileIds,
+                // Persisted receipts are bound again by draft revision, source
+                // fingerprints, filters and snapshot during preflight. They therefore
+                // survive a process restart without making result rows durable.
+                expiresAt: Number.POSITIVE_INFINITY,
+            };
+        }
+        finally {
+            storage.close();
+        }
+    };
     const dbtNodeDetailCache = new Map();
     const onboardingJobs = new Map();
     const metricFlowInstaller = new ManagedMetricFlowInstaller(projectRoot);
@@ -5653,7 +5684,10 @@ export async function startLocalServer(opts) {
                 parameters: invocation.values,
             })
             : null;
-        const validation = validateBlockStudioSource(source, semanticLayer);
+        const staticValidation = validateBlockStudioSource(source, semanticLayer);
+        const validation = semanticCompose
+            ? reconcileBlockStudioRuntimeValidation(staticValidation, semanticCompose)
+            : staticValidation;
         const executableSql = semanticCompose?.sql ?? validation.executableSql;
         if (!executableSql) {
             const message = semanticCompose?.diagnostics.find((item) => item.severity === 'error')?.message
@@ -5675,6 +5709,7 @@ export async function startLocalServer(opts) {
             chartConfig: plan?.chartConfig ?? validation.chartConfig ?? null,
             invocation,
             tests: plan?.tests ?? [],
+            validation,
         };
     };
     const runBlockStudioTestSummary = async (source, targetConnection, executedPreview) => {
@@ -5775,16 +5810,32 @@ export async function startLocalServer(opts) {
         };
     };
     const certifyBlockStudioSource = async (source, blockPath, options = {}) => {
-        const validation = validateBlockStudioSource(source, semanticLayer);
+        options.reportProgress?.({
+            phase: 'validating',
+            progress: 10,
+            message: 'Validating the saved DQL source.',
+        });
+        let validation = validateBlockStudioSource(source, semanticLayer);
         let preview = null;
         let testResults = null;
         const blockers = [];
+        options.reportProgress?.({
+            phase: 'previewing',
+            progress: 30,
+            message: 'Compiling and previewing the saved block.',
+        });
         try {
             preview = await runBlockStudioPreviewSource(source);
+            validation = preview.validation;
         }
         catch (error) {
             blockers.push(error instanceof Error ? error.message : String(error));
         }
+        options.reportProgress?.({
+            phase: 'testing',
+            progress: 60,
+            message: 'Evaluating declared block tests.',
+        });
         try {
             testResults = preview
                 ? await runBlockStudioTestSummary(source, undefined, preview)
@@ -5800,6 +5851,11 @@ export async function startLocalServer(opts) {
                 runAt: new Date(),
             };
         }
+        options.reportProgress?.({
+            phase: 'assessing',
+            progress: 75,
+            message: 'Assessing certification rules and evidence.',
+        });
         const parsed = parseBlockSourceMetadata(source);
         const record = {
             id: parsed.name || 'local',
@@ -9272,633 +9328,659 @@ export async function startLocalServer(opts) {
                         ? body.tileId.trim()
                         : undefined;
                     const tiles = [];
-                    let localApps = null;
-                    for (const item of loaded.dashboard.layout.items) {
-                        if (requestedTileId && item.i !== requestedTileId)
-                            continue;
-                        if (item.text) {
-                            tiles.push({
-                                tileId: item.i,
-                                status: 'ok',
-                                tileType: 'text',
-                                title: item.title,
-                                viz: item.viz,
-                                text: item.text,
-                            });
-                            continue;
-                        }
-                        if (item.aiPin) {
-                            try {
-                                localApps ??= new LocalAppStorage(defaultLocalAppsDbPath(projectRoot));
-                            }
-                            catch (err) {
-                                tiles.push({
-                                    tileId: item.i,
-                                    status: 'error',
-                                    tileType: 'aiPin',
-                                    error: err instanceof Error ? err.message : String(err),
-                                });
+                    const localApps = { current: null };
+                    const itemsToRun = loaded.dashboard.layout.items.filter((item) => !requestedTileId || item.i === requestedTileId);
+                    const tileOrder = new Map(itemsToRun.map((item, index) => [item.i, index]));
+                    let nextTileIndex = 0;
+                    // App preview is a multi-source execution, so isolate each tile's
+                    // failure and run a small fixed pool. Four avoids serial 4k-catalog
+                    // behavior without flooding the configured warehouse.
+                    const runTileWorker = async () => {
+                        while (nextTileIndex < itemsToRun.length) {
+                            const item = itemsToRun[nextTileIndex++];
+                            if (!item)
                                 continue;
-                            }
-                            let pin = localApps.getAiPin(item.aiPin.id);
-                            if (!pin) {
+                            if (item.text) {
                                 tiles.push({
                                     tileId: item.i,
-                                    status: 'unresolved',
-                                    tileType: 'aiPin',
-                                    error: `AI pin "${item.aiPin.id}" could not be found`,
+                                    status: 'ok',
+                                    tileType: 'text',
+                                    title: item.title,
+                                    viz: item.viz,
+                                    text: item.text,
                                 });
                                 continue;
                             }
-                            const pinPlan = pin.analysisPlan && typeof pin.analysisPlan === 'object' && !Array.isArray(pin.analysisPlan)
-                                ? pin.analysisPlan
-                                : undefined;
-                            const pinArtifact = normalizeDqlArtifactReference(pinPlan?.dqlArtifact);
-                            let renderedPinResult = pin.result;
-                            let renderedPinChartConfig = pin.chartConfig;
-                            if (pinArtifact) {
+                            if (item.aiPin) {
                                 try {
-                                    const boundParameters = dashboardTileParameterValues({
-                                        item,
-                                        dashboardValues: dashboardVariables,
-                                        requestValues: variables,
-                                    });
-                                    const executed = await executeDqlArtifactSourceForAgent(pinArtifact.source, { name: pinArtifact.name ?? pin.title, path: pinArtifact.sourcePath }, { question: pin.question, parameters: { ...(pinArtifact.parameterValues ?? {}), ...boundParameters } });
-                                    renderedPinResult = executed;
-                                    renderedPinChartConfig = executed.chartConfig && typeof executed.chartConfig === 'object'
-                                        ? executed.chartConfig
-                                        : renderedPinChartConfig;
+                                    localApps.current ??= new LocalAppStorage(defaultLocalAppsDbPath(projectRoot));
                                 }
                                 catch (err) {
                                     tiles.push({
                                         tileId: item.i,
                                         status: 'error',
                                         tileType: 'aiPin',
-                                        title: item.title ?? pin.title,
                                         error: err instanceof Error ? err.message : String(err),
-                                        trustState: pinArtifact.trustState ?? 'review_required',
                                     });
                                     continue;
                                 }
-                            }
-                            else if (pin.refreshCadence === 'daily' && pin.sql && isAiPinRefreshDue(pin.lastRefreshedAt)) {
-                                try {
-                                    const refreshed = await executeLocalSqlForStoredResult(pin.sql);
-                                    pin = localApps.updateAiPinResult(pin.id, refreshed) ?? pin;
-                                }
-                                catch (err) {
-                                    pin = localApps.updateAiPinResult(pin.id, pin.result, err instanceof Error ? err.message : String(err)) ?? pin;
+                                let pin = localApps.current.getAiPin(item.aiPin.id);
+                                if (!pin) {
+                                    tiles.push({
+                                        tileId: item.i,
+                                        status: 'unresolved',
+                                        tileType: 'aiPin',
+                                        error: `AI pin "${item.aiPin.id}" could not be found`,
+                                    });
+                                    continue;
                                 }
-                            }
-                            tiles.push({
-                                tileId: item.i,
-                                status: 'ok',
-                                tileType: 'aiPin',
-                                title: item.title ?? pin.title,
-                                viz: item.viz,
-                                chartConfig: mergeDashboardChartConfig(renderedPinChartConfig, item),
-                                result: renderedPinResult,
-                                aiPin: pin,
-                                citation: {
-                                    kind: 'ai_pin',
-                                    name: pin.title,
-                                },
-                                artifact: {
-                                    version: 1,
-                                    sourceKind: 'ai_pin',
-                                    name: pinArtifact?.name ?? pin.title,
-                                    ...(pinArtifact?.sourcePath ? { sourcePath: pinArtifact.sourcePath } : {}),
-                                    ...(pinArtifact?.source ? { dql: pinArtifact.source.slice(0, 40_000) } : {}),
-                                    ...(pinArtifact?.compiledSql || pin.sql ? { sql: (pinArtifact?.compiledSql ?? pin.sql).slice(0, 40_000) } : {}),
-                                    trustState: pinArtifact?.trustState === 'certified' || pin.certification === 'certified'
-                                        ? 'certified'
-                                        : 'review_required',
-                                    explanation: [
-                                        'This result comes from a saved App insight.',
-                                        pinArtifact ? 'The DQL artifact was executed again with the current App parameters.' : 'The saved bounded result is displayed with its original trust state.',
-                                    ],
-                                    executionTarget: executionTargetDescriptor(body),
-                                },
-                            });
-                            continue;
-                        }
-                        if (item.draftAnalysis) {
-                            let draftSource;
-                            let draftAppRelativePath;
-                            let draftParameters = {};
-                            let draftTargetConnection;
-                            let draftRepairPlan;
-                            try {
-                                const localDraftPath = loaded.draftArtifactsDir
-                                    ? join(loaded.draftArtifactsDir, item.draftAnalysis.ref)
+                                const pinPlan = pin.analysisPlan && typeof pin.analysisPlan === 'object' && !Array.isArray(pin.analysisPlan)
+                                    ? pin.analysisPlan
                                     : undefined;
-                                const draftRoot = localDraftPath && existsSync(localDraftPath)
-                                    ? loaded.draftArtifactsDir
-                                    : loaded.appDir;
-                                const draftPath = join(draftRoot, item.draftAnalysis.ref);
-                                draftAppRelativePath = relative(draftRoot, draftPath);
-                                if (draftAppRelativePath.startsWith('..') || draftAppRelativePath.startsWith('/')) {
-                                    throw new Error('App-scoped analysis reference escapes the App directory.');
+                                const pinArtifact = normalizeDqlArtifactReference(pinPlan?.dqlArtifact);
+                                let renderedPinResult = pin.result;
+                                let renderedPinChartConfig = pin.chartConfig;
+                                if (pinArtifact) {
+                                    try {
+                                        const boundParameters = dashboardTileParameterValues({
+                                            item,
+                                            dashboardValues: dashboardVariables,
+                                            requestValues: variables,
+                                        });
+                                        const executed = await executeDqlArtifactSourceForAgent(pinArtifact.source, { name: pinArtifact.name ?? pin.title, path: pinArtifact.sourcePath }, { question: pin.question, parameters: { ...(pinArtifact.parameterValues ?? {}), ...boundParameters } });
+                                        renderedPinResult = executed;
+                                        renderedPinChartConfig = executed.chartConfig && typeof executed.chartConfig === 'object'
+                                            ? executed.chartConfig
+                                            : renderedPinChartConfig;
+                                    }
+                                    catch (err) {
+                                        tiles.push({
+                                            tileId: item.i,
+                                            status: 'error',
+                                            tileType: 'aiPin',
+                                            title: item.title ?? pin.title,
+                                            error: err instanceof Error ? err.message : String(err),
+                                            trustState: pinArtifact.trustState ?? 'review_required',
+                                        });
+                                        continue;
+                                    }
                                 }
-                                draftSource = readFileSync(draftPath, 'utf-8');
-                                const fingerprint = `sha256:${createHash('sha256').update(draftSource).digest('hex')}`;
-                                if (fingerprint !== item.draftAnalysis.artifactFingerprint) {
-                                    throw new Error('App-scoped analysis changed after approval. Review the draft again.');
+                                else if (pin.refreshCadence === 'daily' && pin.sql && isAiPinRefreshDue(pin.lastRefreshedAt)) {
+                                    try {
+                                        const refreshed = await executeLocalSqlForStoredResult(pin.sql);
+                                        pin = localApps.current.updateAiPinResult(pin.id, refreshed) ?? pin;
+                                    }
+                                    catch (err) {
+                                        pin = localApps.current.updateAiPinResult(pin.id, pin.result, err instanceof Error ? err.message : String(err)) ?? pin;
+                                    }
                                 }
-                                draftParameters = dashboardTileParameterValues({
-                                    item,
-                                    dashboardValues: dashboardVariables,
-                                    requestValues: variables,
-                                });
-                                draftTargetConnection = isConnectionConfig(body.connection)
-                                    ? body.connection
-                                    : connection ?? undefined;
-                                draftRepairPlan = buildExecutionPlan({ id: item.i, type: 'dql', source: draftSource, title: item.title ?? item.i }, {
-                                    semanticLayer,
-                                    driver: draftTargetConnection?.driver ?? 'duckdb',
-                                    parameters: draftParameters,
+                                tiles.push({
+                                    tileId: item.i,
+                                    status: 'ok',
+                                    tileType: 'aiPin',
+                                    title: item.title ?? pin.title,
+                                    viz: item.viz,
+                                    chartConfig: mergeDashboardChartConfig(renderedPinChartConfig, item),
+                                    result: renderedPinResult,
+                                    aiPin: pin,
+                                    citation: {
+                                        kind: 'ai_pin',
+                                        name: pin.title,
+                                    },
+                                    artifact: {
+                                        version: 1,
+                                        sourceKind: 'ai_pin',
+                                        name: pinArtifact?.name ?? pin.title,
+                                        ...(pinArtifact?.sourcePath ? { sourcePath: pinArtifact.sourcePath } : {}),
+                                        ...(pinArtifact?.source ? { dql: pinArtifact.source.slice(0, 40_000) } : {}),
+                                        ...(pinArtifact?.compiledSql || pin.sql ? { sql: (pinArtifact?.compiledSql ?? pin.sql).slice(0, 40_000) } : {}),
+                                        trustState: pinArtifact?.trustState === 'certified' || pin.certification === 'certified'
+                                            ? 'certified'
+                                            : 'review_required',
+                                        explanation: [
+                                            'This result comes from a saved App insight.',
+                                            pinArtifact ? 'The DQL artifact was executed again with the current App parameters.' : 'The saved bounded result is displayed with its original trust state.',
+                                        ],
+                                        executionTarget: executionTargetDescriptor(body),
+                                    },
                                 });
-                                let result;
-                                let repair;
-                                let repairedSql;
-                                let repairedDql;
+                                continue;
+                            }
+                            if (item.draftAnalysis) {
+                                let draftSource;
+                                let draftAppRelativePath;
+                                let draftParameters = {};
+                                let draftTargetConnection;
+                                let draftRepairPlan;
                                 try {
-                                    result = await executeDqlArtifactSourceForAgent(draftSource, { name: item.title ?? item.i, path: draftAppRelativePath }, { question: item.title, parameters: draftParameters });
+                                    const localDraftPath = loaded.draftArtifactsDir
+                                        ? join(loaded.draftArtifactsDir, item.draftAnalysis.ref)
+                                        : undefined;
+                                    const draftRoot = localDraftPath && existsSync(localDraftPath)
+                                        ? loaded.draftArtifactsDir
+                                        : loaded.appDir;
+                                    const draftPath = join(draftRoot, item.draftAnalysis.ref);
+                                    draftAppRelativePath = relative(draftRoot, draftPath);
+                                    if (draftAppRelativePath.startsWith('..') || draftAppRelativePath.startsWith('/')) {
+                                        throw new Error('App-scoped analysis reference escapes the App directory.');
+                                    }
+                                    draftSource = readFileSync(draftPath, 'utf-8');
+                                    const fingerprint = `sha256:${createHash('sha256').update(draftSource).digest('hex')}`;
+                                    if (fingerprint !== item.draftAnalysis.artifactFingerprint) {
+                                        throw new Error('App-scoped analysis changed after approval. Review the draft again.');
+                                    }
+                                    draftParameters = dashboardTileParameterValues({
+                                        item,
+                                        dashboardValues: dashboardVariables,
+                                        requestValues: variables,
+                                    });
+                                    draftTargetConnection = isConnectionConfig(body.connection)
+                                        ? body.connection
+                                        : connection ?? undefined;
+                                    draftRepairPlan = buildExecutionPlan({ id: item.i, type: 'dql', source: draftSource, title: item.title ?? item.i }, {
+                                        semanticLayer,
+                                        driver: draftTargetConnection?.driver ?? 'duckdb',
+                                        parameters: draftParameters,
+                                    });
+                                    let result;
+                                    let repair;
+                                    let repairedSql;
+                                    let repairedDql;
+                                    try {
+                                        result = await executeDqlArtifactSourceForAgent(draftSource, { name: item.title ?? item.i, path: draftAppRelativePath }, { question: item.title, parameters: draftParameters });
+                                    }
+                                    catch (executionError) {
+                                        const repaired = await repairFailedAppTileExecution({
+                                            source: 'draft_analysis',
+                                            question: item.title ?? item.i,
+                                            sourceSql: draftRepairPlan?.sql,
+                                            sourceDql: draftSource,
+                                            artifactName: item.title ?? item.i,
+                                            error: executionError,
+                                            targetConnection: draftTargetConnection,
+                                            targetConnectionName: projectConfig.defaultConnectionName,
+                                            sqlParams: draftRepairPlan?.sqlParams,
+                                            variables: { ...(draftRepairPlan?.variables ?? {}), ...draftParameters },
+                                        });
+                                        if (!repaired.ok) {
+                                            tiles.push({
+                                                tileId: item.i,
+                                                status: 'error',
+                                                tileType: 'draftAnalysis',
+                                                title: item.title ?? item.i,
+                                                error: executionError instanceof Error ? executionError.message : String(executionError),
+                                                trustState: 'review_required',
+                                                repair: repaired.repair,
+                                                artifact: {
+                                                    version: 1,
+                                                    sourceKind: 'draft_analysis',
+                                                    name: item.title ?? item.i,
+                                                    sourcePath: draftAppRelativePath,
+                                                    dql: draftSource.slice(0, 40_000),
+                                                    ...(draftRepairPlan?.sql ? { sql: draftRepairPlan.sql.slice(0, 40_000) } : {}),
+                                                    trustState: 'review_required',
+                                                    explanation: ['This App-scoped analysis remains review-required.', 'Automatic repair could not produce a safe executable result.'],
+                                                    executionTarget: executionTargetDescriptor(body),
+                                                },
+                                            });
+                                            continue;
+                                        }
+                                        result = repaired.result;
+                                        repair = repaired.repair;
+                                        repairedSql = repaired.repairedSql;
+                                        repairedDql = repaired.repairedDql;
+                                    }
+                                    tiles.push({
+                                        tileId: item.i,
+                                        status: 'ok',
+                                        tileType: 'draftAnalysis',
+                                        title: item.title ?? item.i,
+                                        viz: item.viz,
+                                        chartConfig: mergeDashboardChartConfig(result.chartConfig, item),
+                                        result,
+                                        trustState: 'review_required',
+                                        citation: { kind: repair ? 'app_draft_analysis_repaired' : 'app_draft_analysis', name: item.title ?? item.i, path: draftAppRelativePath },
+                                        ...(repair ? { repair } : {}),
+                                        artifact: {
+                                            version: 1,
+                                            sourceKind: 'draft_analysis',
+                                            name: item.title ?? item.i,
+                                            sourcePath: draftAppRelativePath,
+                                            dql: (repairedDql ?? draftSource).slice(0, 40_000),
+                                            ...(repairedSql ?? draftRepairPlan?.sql ? { sql: (repairedSql ?? draftRepairPlan.sql).slice(0, 40_000) } : {}),
+                                            trustState: 'review_required',
+                                            explanation: [
+                                                'This is private App analysis and remains review-required.',
+                                                repair ? 'A bounded repair ran on the original data target without changing the saved source file.' : 'The saved App-scoped DQL was executed with the current filters.',
+                                            ],
+                                            executionTarget: executionTargetDescriptor(body),
+                                        },
+                                    });
                                 }
-                                catch (executionError) {
+                                catch (err) {
                                     const repaired = await repairFailedAppTileExecution({
                                         source: 'draft_analysis',
                                         question: item.title ?? item.i,
                                         sourceSql: draftRepairPlan?.sql,
                                         sourceDql: draftSource,
                                         artifactName: item.title ?? item.i,
-                                        error: executionError,
+                                        error: err,
                                         targetConnection: draftTargetConnection,
                                         targetConnectionName: projectConfig.defaultConnectionName,
                                         sqlParams: draftRepairPlan?.sqlParams,
                                         variables: { ...(draftRepairPlan?.variables ?? {}), ...draftParameters },
                                     });
-                                    if (!repaired.ok) {
+                                    if (repaired.ok && draftSource) {
                                         tiles.push({
                                             tileId: item.i,
-                                            status: 'error',
+                                            status: 'ok',
                                             tileType: 'draftAnalysis',
                                             title: item.title ?? item.i,
-                                            error: executionError instanceof Error ? executionError.message : String(executionError),
+                                            viz: item.viz,
+                                            chartConfig: mergeDashboardChartConfig(repaired.result.chartConfig, item),
+                                            result: repaired.result,
                                             trustState: 'review_required',
+                                            citation: { kind: 'app_draft_analysis_repaired', name: item.title ?? item.i, path: draftAppRelativePath },
                                             repair: repaired.repair,
                                             artifact: {
                                                 version: 1,
                                                 sourceKind: 'draft_analysis',
                                                 name: item.title ?? item.i,
-                                                sourcePath: draftAppRelativePath,
-                                                dql: draftSource.slice(0, 40_000),
-                                                ...(draftRepairPlan?.sql ? { sql: draftRepairPlan.sql.slice(0, 40_000) } : {}),
+                                                ...(draftAppRelativePath ? { sourcePath: draftAppRelativePath } : {}),
+                                                dql: (repaired.repairedDql ?? draftSource).slice(0, 40_000),
+                                                sql: repaired.repairedSql.slice(0, 40_000),
                                                 trustState: 'review_required',
-                                                explanation: ['This App-scoped analysis remains review-required.', 'Automatic repair could not produce a safe executable result.'],
+                                                explanation: ['A bounded DQL repair executed on the original data target. The saved App analysis was not changed.'],
                                                 executionTarget: executionTargetDescriptor(body),
                                             },
                                         });
                                         continue;
                                     }
-                                    result = repaired.result;
-                                    repair = repaired.repair;
-                                    repairedSql = repaired.repairedSql;
-                                    repairedDql = repaired.repairedDql;
-                                }
-                                tiles.push({
-                                    tileId: item.i,
-                                    status: 'ok',
-                                    tileType: 'draftAnalysis',
-                                    title: item.title ?? item.i,
-                                    viz: item.viz,
-                                    chartConfig: mergeDashboardChartConfig(result.chartConfig, item),
-                                    result,
-                                    trustState: 'review_required',
-                                    citation: { kind: repair ? 'app_draft_analysis_repaired' : 'app_draft_analysis', name: item.title ?? item.i, path: draftAppRelativePath },
-                                    ...(repair ? { repair } : {}),
-                                    artifact: {
-                                        version: 1,
-                                        sourceKind: 'draft_analysis',
-                                        name: item.title ?? item.i,
-                                        sourcePath: draftAppRelativePath,
-                                        dql: (repairedDql ?? draftSource).slice(0, 40_000),
-                                        ...(repairedSql ?? draftRepairPlan?.sql ? { sql: (repairedSql ?? draftRepairPlan.sql).slice(0, 40_000) } : {}),
+                                    tiles.push({
+                                        tileId: item.i,
+                                        status: 'error',
+                                        tileType: 'draftAnalysis',
+                                        title: item.title ?? item.i,
+                                        error: err instanceof Error ? err.message : String(err),
                                         trustState: 'review_required',
-                                        explanation: [
-                                            'This is private App analysis and remains review-required.',
-                                            repair ? 'A bounded repair ran on the original data target without changing the saved source file.' : 'The saved App-scoped DQL was executed with the current filters.',
-                                        ],
-                                        executionTarget: executionTargetDescriptor(body),
-                                    },
-                                });
+                                        repair: repaired.repair,
+                                        ...(draftSource ? {
+                                            artifact: {
+                                                version: 1,
+                                                sourceKind: 'draft_analysis',
+                                                name: item.title ?? item.i,
+                                                ...(draftAppRelativePath ? { sourcePath: draftAppRelativePath } : {}),
+                                                dql: draftSource.slice(0, 40_000),
+                                                ...(draftRepairPlan?.sql ? { sql: draftRepairPlan.sql.slice(0, 40_000) } : {}),
+                                                trustState: 'review_required',
+                                                explanation: ['Automatic repair could not produce a safe executable result. The saved App analysis was not changed.'],
+                                                executionTarget: executionTargetDescriptor(body),
+                                            },
+                                        } : {}),
+                                    });
+                                }
+                                continue;
                             }
-                            catch (err) {
-                                const repaired = await repairFailedAppTileExecution({
-                                    source: 'draft_analysis',
-                                    question: item.title ?? item.i,
-                                    sourceSql: draftRepairPlan?.sql,
-                                    sourceDql: draftSource,
-                                    artifactName: item.title ?? item.i,
-                                    error: err,
-                                    targetConnection: draftTargetConnection,
-                                    targetConnectionName: projectConfig.defaultConnectionName,
-                                    sqlParams: draftRepairPlan?.sqlParams,
-                                    variables: { ...(draftRepairPlan?.variables ?? {}), ...draftParameters },
-                                });
-                                if (repaired.ok && draftSource) {
+                            if (item.semantic) {
+                                try {
+                                    if (!semanticLayer)
+                                        throw new Error('Semantic layer is not available for this governed query.');
+                                    const knownMetrics = new Set(semanticLayer.listMetrics().map((metric) => metric.name));
+                                    const missingMetrics = item.semantic.metrics.filter((metric) => !knownMetrics.has(metric));
+                                    if (missingMetrics.length)
+                                        throw new Error(`Semantic definition changed; missing metric(s): ${missingMetrics.join(', ')}`);
+                                    const knownModels = new Set(semanticLayer.listSemanticModels().map((model) => model.name));
+                                    const missingModels = item.semantic.semanticModelRefs.filter((model) => !knownModels.has(model));
+                                    if (missingModels.length)
+                                        throw new Error(`Semantic definition changed; missing model(s): ${missingModels.join(', ')}`);
+                                    const targetConnection = requireActiveConnection(isConnectionConfig(body.connection) ? body.connection : connection);
+                                    const tableMapping = await resolveSemanticTableMapping(executor, targetConnection, semanticLayer, projectRoot);
+                                    const activeFilters = dashboardSemanticFiltersForTile(loaded.dashboard, item, dashboardVariables);
+                                    const staticFilters = (item.semantic.filters ?? []).map((filter) => ({
+                                        dimension: filter.field,
+                                        operator: filter.operator,
+                                        values: Array.isArray(filter.value) ? filter.value.map(String) : [String(filter.value)],
+                                    }));
+                                    const composed = await composeRuntimeSemanticQuery({
+                                        metrics: item.semantic.metrics,
+                                        dimensions: item.semantic.dimensions ?? [],
+                                        filters: [...staticFilters, ...activeFilters],
+                                        ...(item.semantic.timeDimension ? { timeDimension: { name: item.semantic.timeDimension, granularity: 'month' } } : {}),
+                                        orderBy: item.semantic.orderBy?.map((order) => ({ name: order.field, direction: order.direction })),
+                                        limit: item.semantic.limit,
+                                        engine: item.semantic.provider,
+                                    }, semanticLayer, {
+                                        projectRoot,
+                                        projectConfig,
+                                        detectedProvider: semanticDetectedProvider,
+                                        driver: targetConnection.driver,
+                                        tableMapping,
+                                    });
+                                    if (!composed)
+                                        throw new Error('The governed semantic query could not be composed.');
+                                    const prepared = prepareLocalExecution(composed.sql, targetConnection, projectRoot, projectConfig);
+                                    let normalizedResult;
+                                    let repair;
+                                    let executedSql = composed.sql;
+                                    try {
+                                        const result = await executor.executeQuery(prepared.sql, [], {}, prepared.connection);
+                                        normalizedResult = normalizeQueryResult(result);
+                                    }
+                                    catch (executionError) {
+                                        const repaired = await repairFailedAppTileExecution({
+                                            source: 'semantic_query',
+                                            question: item.title ?? item.semantic.id,
+                                            sourceSql: composed.sql,
+                                            error: executionError,
+                                            targetConnection,
+                                        });
+                                        if (!repaired.ok) {
+                                            tiles.push({
+                                                tileId: item.i,
+                                                status: 'error',
+                                                tileType: 'semantic',
+                                                title: item.title ?? item.semantic.id,
+                                                error: executionError instanceof Error ? executionError.message : String(executionError),
+                                                trustState: 'review_required',
+                                                repair: repaired.repair,
+                                                artifact: {
+                                                    version: 1,
+                                                    sourceKind: 'semantic_query',
+                                                    name: item.title ?? item.semantic.id,
+                                                    sql: composed.sql.slice(0, 40_000),
+                                                    trustState: 'review_required',
+                                                    explanation: ['Automatic repair could not execute the governed semantic query safely.'],
+                                                    executionTarget: executionTargetDescriptor(body),
+                                                },
+                                            });
+                                            continue;
+                                        }
+                                        normalizedResult = normalizeQueryResult(repaired.result);
+                                        repair = repaired.repair;
+                                        executedSql = repaired.repairedSql;
+                                    }
                                     tiles.push({
                                         tileId: item.i,
                                         status: 'ok',
-                                        tileType: 'draftAnalysis',
-                                        title: item.title ?? item.i,
+                                        tileType: 'semantic',
+                                        title: item.title ?? item.semantic.id,
                                         viz: item.viz,
-                                        chartConfig: mergeDashboardChartConfig(repaired.result.chartConfig, item),
-                                        result: repaired.result,
+                                        result: normalizedResult,
                                         trustState: 'review_required',
-                                        citation: { kind: 'app_draft_analysis_repaired', name: item.title ?? item.i, path: draftAppRelativePath },
-                                        repair: repaired.repair,
+                                        citation: { kind: repair ? 'semantic_query_repaired' : 'semantic_query', name: item.semantic.id },
+                                        ...(repair ? { repair } : {}),
                                         artifact: {
                                             version: 1,
-                                            sourceKind: 'draft_analysis',
-                                            name: item.title ?? item.i,
-                                            ...(draftAppRelativePath ? { sourcePath: draftAppRelativePath } : {}),
-                                            dql: (repaired.repairedDql ?? draftSource).slice(0, 40_000),
-                                            sql: repaired.repairedSql.slice(0, 40_000),
+                                            sourceKind: 'semantic_query',
+                                            name: item.title ?? item.semantic.id,
+                                            sql: executedSql.slice(0, 40_000),
                                             trustState: 'review_required',
-                                            explanation: ['A bounded DQL repair executed on the original data target. The saved App analysis was not changed.'],
+                                            explanation: [
+                                                `Metrics: ${item.semantic.metrics.join(', ') || 'none'}.`,
+                                                `Dimensions: ${item.semantic.dimensions?.join(', ') || 'none'}.`,
+                                                repair ? 'The composed SQL needed bounded repair and therefore remains review-required.' : 'The governed semantic intent was composed for the active warehouse and remains review-required until approval.',
+                                            ],
                                             executionTarget: executionTargetDescriptor(body),
                                         },
                                     });
-                                    continue;
                                 }
+                                catch (err) {
+                                    tiles.push({
+                                        tileId: item.i,
+                                        status: 'error',
+                                        tileType: 'semantic',
+                                        title: item.title ?? item.semantic.id,
+                                        error: err instanceof Error ? err.message : String(err),
+                                        trustState: 'review_required',
+                                    });
+                                }
+                                continue;
+                            }
+                            const block = resolveDashboardItemBlock(item, manifest);
+                            if (!block) {
                                 tiles.push({
                                     tileId: item.i,
-                                    status: 'error',
-                                    tileType: 'draftAnalysis',
-                                    title: item.title ?? item.i,
-                                    error: err instanceof Error ? err.message : String(err),
-                                    trustState: 'review_required',
-                                    repair: repaired.repair,
-                                    ...(draftSource ? {
-                                        artifact: {
-                                            version: 1,
-                                            sourceKind: 'draft_analysis',
-                                            name: item.title ?? item.i,
-                                            ...(draftAppRelativePath ? { sourcePath: draftAppRelativePath } : {}),
-                                            dql: draftSource.slice(0, 40_000),
-                                            ...(draftRepairPlan?.sql ? { sql: draftRepairPlan.sql.slice(0, 40_000) } : {}),
-                                            trustState: 'review_required',
-                                            explanation: ['Automatic repair could not produce a safe executable result. The saved App analysis was not changed.'],
-                                            executionTarget: executionTargetDescriptor(body),
-                                        },
-                                    } : {}),
+                                    status: 'unresolved',
+                                    blockRef: item.block ? (isBlockIdRef(item.block) ? item.block.blockId : item.block.ref) : '(missing source)',
+                                    error: 'Block reference could not be resolved',
                                 });
+                                continue;
                             }
-                            continue;
-                        }
-                        if (item.semantic) {
+                            let blockSource;
+                            let blockTargetConnection;
+                            let blockPlan;
+                            let blockFilterApplication;
+                            let blockInvocation;
                             try {
-                                if (!semanticLayer)
-                                    throw new Error('Semantic layer is not available for this governed query.');
-                                const knownMetrics = new Set(semanticLayer.listMetrics().map((metric) => metric.name));
-                                const missingMetrics = item.semantic.metrics.filter((metric) => !knownMetrics.has(metric));
-                                if (missingMetrics.length)
-                                    throw new Error(`Semantic definition changed; missing metric(s): ${missingMetrics.join(', ')}`);
-                                const knownModels = new Set(semanticLayer.listSemanticModels().map((model) => model.name));
-                                const missingModels = item.semantic.semanticModelRefs.filter((model) => !knownModels.has(model));
-                                if (missingModels.length)
-                                    throw new Error(`Semantic definition changed; missing model(s): ${missingModels.join(', ')}`);
-                                const targetConnection = requireActiveConnection(isConnectionConfig(body.connection) ? body.connection : connection);
-                                const tableMapping = await resolveSemanticTableMapping(executor, targetConnection, semanticLayer, projectRoot);
-                                const activeFilters = dashboardSemanticFiltersForTile(loaded.dashboard, item, dashboardVariables);
-                                const staticFilters = (item.semantic.filters ?? []).map((filter) => ({
-                                    dimension: filter.field,
-                                    operator: filter.operator,
-                                    values: Array.isArray(filter.value) ? filter.value.map(String) : [String(filter.value)],
-                                }));
-                                const composed = await composeRuntimeSemanticQuery({
-                                    metrics: item.semantic.metrics,
-                                    dimensions: item.semantic.dimensions ?? [],
-                                    filters: [...staticFilters, ...activeFilters],
-                                    ...(item.semantic.timeDimension ? { timeDimension: { name: item.semantic.timeDimension, granularity: 'month' } } : {}),
-                                    orderBy: item.semantic.orderBy?.map((order) => ({ name: order.field, direction: order.direction })),
-                                    limit: item.semantic.limit,
-                                    engine: item.semantic.provider,
-                                }, semanticLayer, {
-                                    projectRoot,
-                                    projectConfig,
-                                    detectedProvider: semanticDetectedProvider,
-                                    driver: targetConnection.driver,
-                                    tableMapping,
+                                assertAppAccess({
+                                    app: loaded.app,
+                                    domain: block.domain ?? loaded.dashboard.metadata.domain ?? loaded.app.domain,
+                                    level: 'execute',
                                 });
-                                if (!composed)
-                                    throw new Error('The governed semantic query could not be composed.');
-                                const prepared = prepareLocalExecution(composed.sql, targetConnection, projectRoot, projectConfig);
-                                let normalizedResult;
-                                let repair;
-                                let executedSql = composed.sql;
-                                try {
-                                    const result = await executor.executeQuery(prepared.sql, [], {}, prepared.connection);
-                                    normalizedResult = normalizeQueryResult(result);
+                                const absBlockPath = join(projectRoot, block.filePath);
+                                blockSource = readFileSync(absBlockPath, 'utf-8');
+                                const currentSourceRevision = `sha256:${createHash('sha256').update(blockSource).digest('hex')}`;
+                                if (item.sourceRevision && item.sourceRevision !== currentSourceRevision) {
+                                    tiles.push({
+                                        tileId: item.i,
+                                        status: 'error',
+                                        tileType: 'block',
+                                        blockId: block.name,
+                                        blockPath: block.filePath,
+                                        certificationStatus: block.status ?? null,
+                                        title: item.title ?? block.name,
+                                        trustState: 'review_required',
+                                        error: 'This App source changed after it was selected. Refresh the source binding and rerun preview.',
+                                    });
+                                    continue;
                                 }
-                                catch (executionError) {
-                                    const repaired = await repairFailedAppTileExecution({
-                                        source: 'semantic_query',
-                                        question: item.title ?? item.semantic.id,
-                                        sourceSql: composed.sql,
-                                        error: executionError,
-                                        targetConnection,
+                                blockTargetConnection = requireActiveConnection(isConnectionConfig(body.connection) ? body.connection : connection);
+                                const tableMapping = await resolveSemanticTableMapping(executor, blockTargetConnection, semanticLayer, projectRoot);
+                                const boundParameters = dashboardTileParameterValues({
+                                    item,
+                                    dashboardValues: dashboardVariables,
+                                    requestValues: variables,
+                                });
+                                blockInvocation = prepareBlockInvocation({
+                                    block: block.name,
+                                    source: blockSource,
+                                    parameters: { ...dashboardVariables, ...boundParameters },
+                                    parameterSources: Object.fromEntries(Object.keys(boundParameters).map((name) => [name, 'surface'])),
+                                    surface: 'app',
+                                });
+                                if (blockInvocation.errors.length || blockInvocation.unresolvedParameters.length) {
+                                    tiles.push({
+                                        tileId: item.i,
+                                        status: 'unresolved',
+                                        tileType: 'block',
+                                        blockId: block.name,
+                                        title: item.title ?? block.name,
+                                        error: blockInvocation.errors[0] ?? `Needs values for: ${blockInvocation.unresolvedParameters.join(', ')}`,
+                                        invocation: {
+                                            resolvedParameters: blockInvocation.resolvedParameters,
+                                            unresolvedParameters: blockInvocation.unresolvedParameters,
+                                            auditId: blockInvocation.auditId,
+                                        },
                                     });
-                                    if (!repaired.ok) {
-                                        tiles.push({
-                                            tileId: item.i,
-                                            status: 'error',
-                                            tileType: 'semantic',
-                                            title: item.title ?? item.semantic.id,
-                                            error: executionError instanceof Error ? executionError.message : String(executionError),
-                                            trustState: 'review_required',
-                                            repair: repaired.repair,
-                                            artifact: {
-                                                version: 1,
-                                                sourceKind: 'semantic_query',
-                                                name: item.title ?? item.semantic.id,
-                                                sql: composed.sql.slice(0, 40_000),
-                                                trustState: 'review_required',
-                                                explanation: ['Automatic repair could not execute the governed semantic query safely.'],
-                                                executionTarget: executionTargetDescriptor(body),
-                                            },
-                                        });
-                                        continue;
-                                    }
-                                    normalizedResult = normalizeQueryResult(repaired.result);
-                                    repair = repaired.repair;
-                                    executedSql = repaired.repairedSql;
+                                    continue;
                                 }
-                                tiles.push({
-                                    tileId: item.i,
-                                    status: 'ok',
-                                    tileType: 'semantic',
-                                    title: item.title ?? item.semantic.id,
-                                    viz: item.viz,
-                                    result: normalizedResult,
-                                    trustState: 'review_required',
-                                    citation: { kind: repair ? 'semantic_query_repaired' : 'semantic_query', name: item.semantic.id },
-                                    ...(repair ? { repair } : {}),
-                                    artifact: {
-                                        version: 1,
-                                        sourceKind: 'semantic_query',
-                                        name: item.title ?? item.semantic.id,
-                                        sql: executedSql.slice(0, 40_000),
-                                        trustState: 'review_required',
-                                        explanation: [
-                                            `Metrics: ${item.semantic.metrics.join(', ') || 'none'}.`,
-                                            `Dimensions: ${item.semantic.dimensions?.join(', ') || 'none'}.`,
-                                            repair ? 'The composed SQL needed bounded repair and therefore remains review-required.' : 'The governed semantic intent was composed for the active warehouse and remains review-required until approval.',
-                                        ],
-                                        executionTarget: executionTargetDescriptor(body),
-                                    },
+                                const semanticCompose = semanticLayer
+                                    ? await composeSemanticBlockSqlForRuntime(blockSource, semanticLayer, {
+                                        driver: blockTargetConnection.driver,
+                                        tableMapping,
+                                        projectRoot,
+                                        projectConfig,
+                                        detectedProvider: semanticDetectedProvider,
+                                        parameters: blockInvocation.values,
+                                    })
+                                    : null;
+                                blockPlan = buildExecutionPlan({ id: item.i, type: 'dql', source: blockSource, title: item.title ?? block.name }, {
+                                    semanticLayer,
+                                    driver: blockTargetConnection.driver,
+                                    tableMapping,
+                                    parameters: blockInvocation.values,
+                                    semanticSql: semanticCompose?.sql ?? undefined,
                                 });
-                            }
-                            catch (err) {
-                                tiles.push({
+                                if (!blockPlan && !semanticCompose?.sql) {
+                                    tiles.push({
+                                        tileId: item.i,
+                                        status: 'error',
+                                        blockId: block.name,
+                                        error: semanticCompose?.diagnostics.find((diagnostic) => diagnostic.severity === 'error')?.message ?? 'Block produced no executable plan',
+                                    });
+                                    continue;
+                                }
+                                blockFilterApplication = applyDashboardFiltersToBlockExecution({
+                                    sql: semanticCompose?.sql ?? blockPlan.sql,
+                                    sqlParams: blockPlan?.sqlParams ?? [],
+                                    variables: { ...(blockPlan?.variables ?? {}), ...dashboardVariables },
+                                    block,
+                                    dashboard: loaded.dashboard,
                                     tileId: item.i,
-                                    status: 'error',
-                                    tileType: 'semantic',
-                                    title: item.title ?? item.semantic.id,
-                                    error: err instanceof Error ? err.message : String(err),
-                                    trustState: 'review_required',
+                                    tileFilterBindings: item.filterBindings,
                                 });
-                            }
-                            continue;
-                        }
-                        const block = resolveDashboardItemBlock(item, manifest);
-                        if (!block) {
-                            tiles.push({
-                                tileId: item.i,
-                                status: 'unresolved',
-                                blockRef: item.block ? (isBlockIdRef(item.block) ? item.block.blockId : item.block.ref) : '(missing source)',
-                                error: 'Block reference could not be resolved',
-                            });
-                            continue;
-                        }
-                        let blockSource;
-                        let blockTargetConnection;
-                        let blockPlan;
-                        let blockFilterApplication;
-                        let blockInvocation;
-                        try {
-                            assertAppAccess({
-                                app: loaded.app,
-                                domain: block.domain ?? loaded.dashboard.metadata.domain ?? loaded.app.domain,
-                                level: 'execute',
-                            });
-                            const absBlockPath = join(projectRoot, block.filePath);
-                            blockSource = readFileSync(absBlockPath, 'utf-8');
-                            blockTargetConnection = requireActiveConnection(isConnectionConfig(body.connection) ? body.connection : connection);
-                            const tableMapping = await resolveSemanticTableMapping(executor, blockTargetConnection, semanticLayer, projectRoot);
-                            const boundParameters = dashboardTileParameterValues({
-                                item,
-                                dashboardValues: dashboardVariables,
-                                requestValues: variables,
-                            });
-                            blockInvocation = prepareBlockInvocation({
-                                block: block.name,
-                                source: blockSource,
-                                parameters: { ...dashboardVariables, ...boundParameters },
-                                parameterSources: Object.fromEntries(Object.keys(boundParameters).map((name) => [name, 'surface'])),
-                                surface: 'app',
-                            });
-                            if (blockInvocation.errors.length || blockInvocation.unresolvedParameters.length) {
+                                const prepared = prepareLocalExecution(blockFilterApplication.sql, blockTargetConnection, projectRoot, projectConfig);
+                                const result = await executor.executeQuery(prepared.sql, blockFilterApplication.sqlParams, runtimeVariables({ ...blockFilterApplication.variables, ...blockInvocation.values }), prepared.connection);
                                 tiles.push({
                                     tileId: item.i,
-                                    status: 'unresolved',
-                                    tileType: 'block',
+                                    status: 'ok',
                                     blockId: block.name,
+                                    blockPath: block.filePath,
+                                    certificationStatus: block.status ?? null,
                                     title: item.title ?? block.name,
-                                    error: blockInvocation.errors[0] ?? `Needs values for: ${blockInvocation.unresolvedParameters.join(', ')}`,
+                                    viz: item.viz,
+                                    chartConfig: mergeDashboardChartConfig(blockPlan?.chartConfig, item),
+                                    result: normalizeQueryResult(result),
+                                    filters: {
+                                        applied: blockFilterApplication.appliedFilters,
+                                        skipped: blockFilterApplication.skippedFilters,
+                                    },
                                     invocation: {
                                         resolvedParameters: blockInvocation.resolvedParameters,
                                         unresolvedParameters: blockInvocation.unresolvedParameters,
                                         auditId: blockInvocation.auditId,
                                     },
-                                });
-                                continue;
-                            }
-                            const semanticCompose = semanticLayer
-                                ? await composeSemanticBlockSqlForRuntime(blockSource, semanticLayer, {
-                                    driver: blockTargetConnection.driver,
-                                    tableMapping,
-                                    projectRoot,
-                                    projectConfig,
-                                    detectedProvider: semanticDetectedProvider,
-                                    parameters: blockInvocation.values,
-                                })
-                                : null;
-                            blockPlan = buildExecutionPlan({ id: item.i, type: 'dql', source: blockSource, title: item.title ?? block.name }, {
-                                semanticLayer,
-                                driver: blockTargetConnection.driver,
-                                tableMapping,
-                                parameters: blockInvocation.values,
-                                semanticSql: semanticCompose?.sql ?? undefined,
-                            });
-                            if (!blockPlan && !semanticCompose?.sql) {
-                                tiles.push({
-                                    tileId: item.i,
-                                    status: 'error',
-                                    blockId: block.name,
-                                    error: semanticCompose?.diagnostics.find((diagnostic) => diagnostic.severity === 'error')?.message ?? 'Block produced no executable plan',
-                                });
-                                continue;
-                            }
-                            blockFilterApplication = applyDashboardFiltersToBlockExecution({
-                                sql: semanticCompose?.sql ?? blockPlan.sql,
-                                sqlParams: blockPlan?.sqlParams ?? [],
-                                variables: { ...(blockPlan?.variables ?? {}), ...dashboardVariables },
-                                block,
-                                dashboard: loaded.dashboard,
-                                tileId: item.i,
-                                tileFilterBindings: item.filterBindings,
-                            });
-                            const prepared = prepareLocalExecution(blockFilterApplication.sql, blockTargetConnection, projectRoot, projectConfig);
-                            const result = await executor.executeQuery(prepared.sql, blockFilterApplication.sqlParams, runtimeVariables({ ...blockFilterApplication.variables, ...blockInvocation.values }), prepared.connection);
-                            tiles.push({
-                                tileId: item.i,
-                                status: 'ok',
-                                blockId: block.name,
-                                blockPath: block.filePath,
-                                certificationStatus: block.status ?? null,
-                                title: item.title ?? block.name,
-                                viz: item.viz,
-                                chartConfig: mergeDashboardChartConfig(blockPlan?.chartConfig, item),
-                                result: normalizeQueryResult(result),
-                                filters: {
-                                    applied: blockFilterApplication.appliedFilters,
-                                    skipped: blockFilterApplication.skippedFilters,
-                                },
-                                invocation: {
-                                    resolvedParameters: blockInvocation.resolvedParameters,
-                                    unresolvedParameters: blockInvocation.unresolvedParameters,
-                                    auditId: blockInvocation.auditId,
-                                },
-                                trustState: block.status === 'certified' ? 'certified' : 'review_required',
-                                citation: {
-                                    kind: 'block',
-                                    name: block.name,
-                                    path: block.filePath,
-                                },
-                                artifact: {
-                                    version: 1,
-                                    sourceKind: 'certified_block',
-                                    name: block.name,
-                                    sourcePath: block.filePath,
-                                    dql: blockSource.slice(0, 40_000),
-                                    sql: blockFilterApplication.sql.slice(0, 40_000),
                                     trustState: block.status === 'certified' ? 'certified' : 'review_required',
-                                    explanation: [
-                                        block.status === 'certified' ? 'This tile executed a certified project block.' : 'This project block is not certified and remains review-required.',
-                                        'Dashboard filters and typed parameters were bound before read-only execution.',
-                                    ],
-                                    executionTarget: executionTargetDescriptor(body),
-                                },
-                            });
-                        }
-                        catch (err) {
-                            if (err instanceof DQLAccessDeniedError) {
-                                tiles.push({
-                                    tileId: item.i,
-                                    status: 'unauthorized',
-                                    blockId: block.name,
-                                    error: err.message,
-                                });
-                            }
-                            else {
-                                const repaired = await repairFailedAppTileExecution({
-                                    source: 'certified_block',
-                                    question: item.title ?? block.name,
-                                    sourceSql: blockFilterApplication?.sql ?? blockPlan?.sql,
-                                    sourceDql: blockSource,
-                                    artifactName: block.name,
-                                    error: err,
-                                    targetConnection: blockTargetConnection,
-                                    targetConnectionName: projectConfig.defaultConnectionName,
-                                    sqlParams: blockFilterApplication?.sqlParams ?? blockPlan?.sqlParams,
-                                    variables: {
-                                        ...(blockPlan?.variables ?? {}),
-                                        ...(blockFilterApplication?.variables ?? {}),
-                                        ...(blockInvocation?.values ?? {}),
+                                    citation: {
+                                        kind: 'block',
+                                        name: block.name,
+                                        path: block.filePath,
+                                    },
+                                    artifact: {
+                                        version: 1,
+                                        sourceKind: block.status === 'certified' ? 'certified_block' : 'review_block',
+                                        name: block.name,
+                                        sourcePath: block.filePath,
+                                        dql: blockSource.slice(0, 40_000),
+                                        sql: blockFilterApplication.sql.slice(0, 40_000),
+                                        trustState: block.status === 'certified' ? 'certified' : 'review_required',
+                                        explanation: [
+                                            block.status === 'certified' ? 'This tile executed a certified project block.' : 'This project block is not certified and remains review-required.',
+                                            'Dashboard filters and typed parameters were bound before read-only execution.',
+                                        ],
+                                        executionTarget: executionTargetDescriptor(body),
                                     },
                                 });
-                                if (repaired.ok) {
+                            }
+                            catch (err) {
+                                if (err instanceof DQLAccessDeniedError) {
                                     tiles.push({
                                         tileId: item.i,
-                                        status: 'ok',
-                                        tileType: 'block',
+                                        status: 'unauthorized',
                                         blockId: block.name,
-                                        blockPath: block.filePath,
-                                        certificationStatus: block.status ?? null,
-                                        title: item.title ?? block.name,
-                                        viz: item.viz,
-                                        chartConfig: mergeDashboardChartConfig(blockPlan?.chartConfig, item),
-                                        result: normalizeQueryResult(repaired.result),
-                                        ...(blockFilterApplication ? {
-                                            filters: {
-                                                applied: blockFilterApplication.appliedFilters,
-                                                skipped: blockFilterApplication.skippedFilters,
+                                        error: err.message,
+                                    });
+                                }
+                                else {
+                                    const repaired = await repairFailedAppTileExecution({
+                                        source: block.status === 'certified' ? 'certified_block' : 'review_block',
+                                        question: item.title ?? block.name,
+                                        sourceSql: blockFilterApplication?.sql ?? blockPlan?.sql,
+                                        sourceDql: blockSource,
+                                        artifactName: block.name,
+                                        error: err,
+                                        targetConnection: blockTargetConnection,
+                                        targetConnectionName: projectConfig.defaultConnectionName,
+                                        sqlParams: blockFilterApplication?.sqlParams ?? blockPlan?.sqlParams,
+                                        variables: {
+                                            ...(blockPlan?.variables ?? {}),
+                                            ...(blockFilterApplication?.variables ?? {}),
+                                            ...(blockInvocation?.values ?? {}),
+                                        },
+                                    });
+                                    if (repaired.ok) {
+                                        tiles.push({
+                                            tileId: item.i,
+                                            status: 'ok',
+                                            tileType: 'block',
+                                            blockId: block.name,
+                                            blockPath: block.filePath,
+                                            certificationStatus: block.status ?? null,
+                                            title: item.title ?? block.name,
+                                            viz: item.viz,
+                                            chartConfig: mergeDashboardChartConfig(blockPlan?.chartConfig, item),
+                                            result: normalizeQueryResult(repaired.result),
+                                            ...(blockFilterApplication ? {
+                                                filters: {
+                                                    applied: blockFilterApplication.appliedFilters,
+                                                    skipped: blockFilterApplication.skippedFilters,
+                                                },
+                                            } : {}),
+                                            ...(blockInvocation ? {
+                                                invocation: {
+                                                    resolvedParameters: blockInvocation.resolvedParameters,
+                                                    unresolvedParameters: blockInvocation.unresolvedParameters,
+                                                    auditId: blockInvocation.auditId,
+                                                },
+                                            } : {}),
+                                            trustState: 'review_required',
+                                            repair: repaired.repair,
+                                            citation: { kind: 'block_repaired', name: block.name, path: block.filePath },
+                                            artifact: {
+                                                version: 1,
+                                                sourceKind: block.status === 'certified' ? 'certified_block' : 'review_block',
+                                                name: block.name,
+                                                sourcePath: block.filePath,
+                                                ...(repaired.repairedDql ?? blockSource ? { dql: (repaired.repairedDql ?? blockSource).slice(0, 40_000) } : {}),
+                                                sql: repaired.repairedSql.slice(0, 40_000),
+                                                trustState: 'review_required',
+                                                explanation: [
+                                                    'The saved certified block was not changed.',
+                                                    'A bounded repair executed on the original data target; this repaired result requires human review.',
+                                                ],
+                                                executionTarget: executionTargetDescriptor(body),
                                             },
-                                        } : {}),
-                                        ...(blockInvocation ? {
-                                            invocation: {
-                                                resolvedParameters: blockInvocation.resolvedParameters,
-                                                unresolvedParameters: blockInvocation.unresolvedParameters,
-                                                auditId: blockInvocation.auditId,
+                                        });
+                                        continue;
+                                    }
+                                    tiles.push({
+                                        tileId: item.i,
+                                        status: 'error',
+                                        tileType: 'block',
+                                        blockId: block.name,
+                                        error: err instanceof Error ? err.message : String(err),
+                                        repair: repaired.repair,
+                                        ...(blockSource ? {
+                                            artifact: {
+                                                version: 1,
+                                                sourceKind: block.status === 'certified' ? 'certified_block' : 'review_block',
+                                                name: block.name,
+                                                sourcePath: block.filePath,
+                                                dql: blockSource.slice(0, 40_000),
+                                                ...(blockFilterApplication?.sql ?? blockPlan?.sql ? { sql: (blockFilterApplication?.sql ?? blockPlan.sql).slice(0, 40_000) } : {}),
+                                                trustState: 'review_required',
+                                                explanation: ['Automatic repair could not produce a safe executable result. The saved block was not changed.'],
+                                                executionTarget: executionTargetDescriptor(body),
                                             },
                                         } : {}),
-                                        trustState: 'review_required',
-                                        repair: repaired.repair,
-                                        citation: { kind: 'block_repaired', name: block.name, path: block.filePath },
-                                        artifact: {
-                                            version: 1,
-                                            sourceKind: 'certified_block',
-                                            name: block.name,
-                                            sourcePath: block.filePath,
-                                            ...(repaired.repairedDql ?? blockSource ? { dql: (repaired.repairedDql ?? blockSource).slice(0, 40_000) } : {}),
-                                            sql: repaired.repairedSql.slice(0, 40_000),
-                                            trustState: 'review_required',
-                                            explanation: [
-                                                'The saved certified block was not changed.',
-                                                'A bounded repair executed on the original data target; this repaired result requires human review.',
-                                            ],
-                                            executionTarget: executionTargetDescriptor(body),
-                                        },
                                     });
-                                    continue;
                                 }
-                                tiles.push({
-                                    tileId: item.i,
-                                    status: 'error',
-                                    tileType: 'block',
-                                    blockId: block.name,
-                                    error: err instanceof Error ? err.message : String(err),
-                                    repair: repaired.repair,
-                                    ...(blockSource ? {
-                                        artifact: {
-                                            version: 1,
-                                            sourceKind: 'certified_block',
-                                            name: block.name,
-                                            sourcePath: block.filePath,
-                                            dql: blockSource.slice(0, 40_000),
-                                            ...(blockFilterApplication?.sql ?? blockPlan?.sql ? { sql: (blockFilterApplication?.sql ?? blockPlan.sql).slice(0, 40_000) } : {}),
-                                            trustState: 'review_required',
-                                            explanation: ['Automatic repair could not produce a safe executable result. The saved block was not changed.'],
-                                            executionTarget: executionTargetDescriptor(body),
-                                        },
-                                    } : {}),
-                                });
                             }
                         }
-                    }
-                    localApps?.close();
+                    };
+                    await Promise.all(Array.from({ length: Math.min(4, itemsToRun.length) }, () => runTileWorker()));
+                    tiles.sort((left, right) => (tileOrder.get(left.tileId) ?? 0) - (tileOrder.get(right.tileId) ?? 0));
+                    localApps.current?.close();
                     // Which of each tile's result columns a viewer may safely filter on.
                     // Decided here, from a real dialect parse of the SQL that actually ran,
                     // for the same reason Ask does it server-side: an aggregate output needs
@@ -9920,7 +10002,7 @@ export async function startLocalServer(opts) {
                         try {
                             const dashboardItem = loaded.dashboard.layout.items.find((item) => item.i === tile.tileId);
                             const block = dashboardItem ? resolveDashboardItemBlock(dashboardItem, manifest) : null;
-                            const declaredDimensions = block?.status === 'certified' ? block.dimensions ?? [] : [];
+                            const declaredDimensions = block?.dimensions ?? [];
                             const filterable = dashboardFilterableResultColumns(executedSql, columns, declaredDimensions, runDialect);
                             return filterable.length > 0 ? { ...tile, filterableColumns: filterable } : tile;
                         }
@@ -9951,7 +10033,7 @@ export async function startLocalServer(opts) {
                         eligibleTileIds: loaded.dashboard.story?.eligibleTileIds,
                         driverTileIds: loaded.dashboard.story?.driverTileIds,
                     });
-                    dashboardRunEvidence.set(runId, {
+                    const runEvidence = {
                         appId,
                         dashboardId,
                         snapshotId: snapshot.snapshotId,
@@ -9965,7 +10047,28 @@ export async function startLocalServer(opts) {
                         facts: storyResult.facts,
                         story: storyResult.story,
                         expiresAt: Date.now() + 15 * 60_000,
-                    });
+                    };
+                    dashboardRunEvidence.set(runId, runEvidence);
+                    if (runSurface === 'app-builds') {
+                        const receiptStorage = new LocalAppStorage(defaultLocalAppsDbPath(projectRoot));
+                        try {
+                            receiptStorage.saveAppPreviewEvidence({
+                                runId,
+                                draftId: appId,
+                                dashboardId,
+                                snapshotId: snapshot.snapshotId,
+                                filterFingerprint,
+                                resultFingerprint,
+                                personaFingerprint,
+                                successfulTileIds: runEvidence.successfulTileIds,
+                                semanticApprovalEligibleTileIds: runEvidence.semanticApprovalEligibleTileIds,
+                                createdAt: new Date().toISOString(),
+                            });
+                        }
+                        finally {
+                            receiptStorage.close();
+                        }
+                    }
                     for (const [id, evidence] of dashboardRunEvidence)
                         if (evidence.expiresAt < Date.now())
                             dashboardRunEvidence.delete(id);
@@ -10019,6 +10122,17 @@ export async function startLocalServer(opts) {
                         // questions. Throws when no provider is configured — propose degrades
                         // gracefully by listing the gap instead.
                         generateGovernedAnswer: (question, appContext) => generateAppBuildAnswerWithRepair(question, appContext),
+                        // App Builder owns its orchestration and structured state. It shares
+                        // only the configured provider adapter with Ask/Notebook.
+                        planAppBuild: async ({ system, user }) => {
+                            const provider = await createBlockStudioAssistProvider(projectRoot);
+                            if (!provider)
+                                return undefined;
+                            return provider.generate([
+                                { role: 'system', content: system },
+                                { role: 'user', content: user },
+                            ], { maxTokens: 2_400, temperature: 0.1 });
+                        },
                         queueOperation: (input, task) => {
                             const operation = operationCoordinator.create(input);
                             void operationCoordinator.run(operation.id, task);
@@ -10043,9 +10157,9 @@ export async function startLocalServer(opts) {
                             return { ok: true, snapshotId: evidence.snapshotId, resultFingerprint: evidence.resultFingerprint };
                         },
                         verifyAppBuildPreview: ({ runId, draftId, dashboardId, tileIds }) => {
-                            const evidence = dashboardRunEvidence.get(runId);
-                            if (!evidence || evidence.expiresAt < Date.now())
-                                return { ok: false, error: 'The App preview receipt expired. Run the local draft again.' };
+                            const evidence = loadAppBuildPreviewEvidence(runId);
+                            if (!evidence)
+                                return { ok: false, error: 'The App preview receipt is unavailable. Run the local draft again.' };
                             if (evidence.appId !== draftId || evidence.dashboardId !== dashboardId)
                                 return { ok: false, error: 'The App preview receipt does not match this local draft page.' };
                             const successful = new Set(evidence.successfulTileIds);
@@ -11596,7 +11710,7 @@ export async function startLocalServer(opts) {
                             return;
                         }
                     }
-                    const draftSource = setBlockStudioStatusInSource(source, 'draft');
+                    const draftSource = markBlockStudioSourceReusable(setBlockStudioStatusInSource(source, 'draft'));
                     const parsed = parseBlockSourceMetadata(draftSource);
                     const name = typeof suppliedMetadata.name === 'string' && suppliedMetadata.name.trim()
                         ? suppliedMetadata.name.trim()
@@ -11606,22 +11720,38 @@ export async function startLocalServer(opts) {
                         res.end(serializeJSON({ error: 'Block name is required.' }));
                         return;
                     }
-                    const canonicalPath = currentPath && !isDraftBlockPath(currentPath) ? currentPath : undefined;
+                    const existingCanonicalDraft = Boolean(currentPath && !isDraftBlockPath(currentPath));
                     const stableSuffix = createHash('sha256')
                         .update(currentPath ?? `${name}:${draftSource}`)
                         .digest('hex')
                         .slice(0, 16);
-                    const draftPath = saveBlockStudioDraftArtifacts(projectRoot, {
-                        currentPath: currentPath && isDraftBlockPath(currentPath) ? currentPath : undefined,
+                    const draftSaveOptions = {
                         source: draftSource,
                         name,
                         domain: typeof suppliedMetadata.domain === 'string' ? suppliedMetadata.domain : parsed.domain,
                         description: typeof suppliedMetadata.description === 'string' ? suppliedMetadata.description : parsed.description,
                         owner: typeof suppliedMetadata.owner === 'string' ? suppliedMetadata.owner : parsed.owner,
-                        tags: Array.isArray(suppliedMetadata.tags) ? suppliedMetadata.tags.map(String) : parsed.tags,
+                        tags: Array.from(new Set([
+                            ...(Array.isArray(suppliedMetadata.tags) ? suppliedMetadata.tags.map(String) : parsed.tags),
+                            APP_SOURCE_REUSABLE_TAG,
+                        ])),
                         lineage: Array.isArray(suppliedMetadata.lineage) ? suppliedMetadata.lineage.map(String) : undefined,
-                        stableSuffix,
-                    });
+                    };
+                    // A saved draft already has a durable identity, even when it lives in
+                    // the canonical domain blocks directory. Reuse that identity for the
+                    // certification attempt. Creating a second `_drafts` artifact here
+                    // made a failed gate duplicate the block in the library.
+                    const draftPath = existingCanonicalDraft
+                        ? saveBlockStudioArtifacts(projectRoot, {
+                            currentPath: currentPath,
+                            ...draftSaveOptions,
+                        })
+                        : saveBlockStudioDraftArtifacts(projectRoot, {
+                            currentPath: currentPath && isDraftBlockPath(currentPath) ? currentPath : undefined,
+                            ...draftSaveOptions,
+                            stableSuffix,
+                        });
+                    const canonicalPath = existingCanonicalDraft ? draftPath : undefined;
                     const operation = operationCoordinator.create({
                         type: 'block_certification',
                         scope: `block:${draftPath}`,
@@ -11641,22 +11771,37 @@ export async function startLocalServer(opts) {
                         }
                     }
                     operationCoordinator.run(operation.id, async (signal, report) => {
-                        report({ phase: 'validating', progress: 15, message: 'Validating and running the saved draft once.' });
-                        const result = await certifyBlockStudioSource(draftSource, draftPath, { enterprise: body.enterprise === true });
+                        const result = await certifyBlockStudioSource(draftSource, draftPath, {
+                            enterprise: body.enterprise === true,
+                            reportProgress: (progress) => {
+                                if (signal.aborted)
+                                    throw Object.assign(new Error('Certification cancelled.'), { code: 'OPERATION_CANCELLED' });
+                                report(progress);
+                            },
+                        });
                         const blockers = Array.from(new Set(result.checklist.blockers));
                         if (signal.aborted)
                             throw Object.assign(new Error('Certification cancelled.'), { code: 'OPERATION_CANCELLED' });
                         if (!result.certification.certified || blockers.length > 0) {
+                            if (result.preview)
+                                writeBlockStudioRunSummary(projectRoot, draftPath, draftSource, result.preview.result);
+                            const openedDraft = openBlockStudioDocument(projectRoot, draftPath, semanticLayer);
                             return {
                                 outcome: 'draft_saved_with_blockers',
                                 oldPath: currentPath ?? draftPath,
                                 draftPath,
                                 blockers,
                                 checklist: result.checklist,
-                                block: openBlockStudioDocument(projectRoot, draftPath, semanticLayer),
+                                runSummary: result.preview ? {
+                                    rowCount: result.preview.result.rowCount ?? result.preview.result.rows.length,
+                                    executionTime: result.preview.result.executionTime,
+                                    columns: result.preview.result.columns,
+                                    ranAt: new Date().toISOString(),
+                                } : undefined,
+                                block: { ...openedDraft, validation: result.validation },
                             };
                         }
-                        report({ phase: 'publishing', progress: 80, message: 'Publishing the certified block.' });
+                        report({ phase: 'publishing', progress: 82, message: 'Publishing the certified block.' });
                         const certifiedSource = setBlockStudioStatusInSource(draftSource, 'certified');
                         const certifiedMetadata = parseBlockSourceMetadata(certifiedSource);
                         const savedPath = saveBlockStudioArtifacts(projectRoot, {
@@ -11698,14 +11843,25 @@ export async function startLocalServer(opts) {
                         catch {
                             /* best-effort: learning capture must never block certification */
                         }
+                        report({ phase: 'indexing', progress: 92, message: 'Queueing the certified source index refresh.' });
                         const refreshOperation = scheduleProjectRefresh('block-studio-certification');
+                        report({ phase: 'indexing', progress: 96, message: 'Certified source saved; index refresh queued.' });
+                        if (result.preview)
+                            writeBlockStudioRunSummary(projectRoot, savedPath, certifiedSource, result.preview.result);
+                        const openedCertified = openBlockStudioDocument(projectRoot, savedPath, semanticLayer);
                         return {
                             outcome: 'certified',
                             oldPath: currentPath ?? draftPath,
                             draftPath,
                             newPath: savedPath,
-                            block: openBlockStudioDocument(projectRoot, savedPath, semanticLayer),
+                            block: { ...openedCertified, validation: result.validation },
                             checklist: result.checklist,
+                            runSummary: result.preview ? {
+                                rowCount: result.preview.result.rowCount ?? result.preview.result.rows.length,
+                                executionTime: result.preview.result.executionTime,
+                                columns: result.preview.result.columns,
+                                ranAt: new Date().toISOString(),
+                            } : undefined,
                             indexRefresh: { status: 'queued', operationId: refreshOperation.id },
                         };
                     });
@@ -11723,6 +11879,32 @@ export async function startLocalServer(opts) {
                 }
                 return;
             }
+            if (req.method === 'POST' && path === '/api/block-studio/certification-check') {
+                try {
+                    const body = await readJSON(req);
+                    const source = typeof body.source === 'string' ? body.source : '';
+                    if (!source.trim()) {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(serializeJSON({ error: 'source is required' }));
+                        return;
+                    }
+                    // Read-only certification assessment for repair/review workflows. It
+                    // deliberately does not write source, receipts, learning, or indexes.
+                    const result = await certifyBlockStudioSource(source, null, { enterprise: body.enterprise === true });
+                    const blockers = Array.from(new Set(result.checklist.blockers));
+                    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({
+                        ok: result.certification.certified && blockers.length === 0,
+                        ...result,
+                        blockers,
+                    }));
+                }
+                catch (error) {
+                    res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({ error: error instanceof Error ? error.message : String(error) }));
+                }
+                return;
+            }
             if (req.method === 'POST' && path === '/api/block-studio/certify') {
                 try {
                     const body = await readJSON(req);
@@ -11740,6 +11922,8 @@ export async function startLocalServer(opts) {
                     const result = await certifyBlockStudioSource(source, blockPath, { enterprise: body.enterprise === true });
                     const blockers = Array.from(new Set(result.checklist.blockers));
                     if (!result.certification.certified || blockers.length > 0) {
+                        if (blockPath && result.preview)
+                            writeBlockStudioRunSummary(projectRoot, blockPath, source, result.preview.result);
                         res.writeHead(422, { 'Content-Type': 'application/json; charset=utf-8' });
                         res.end(serializeJSON({ ok: false, ...result, blockers }));
                         return;
@@ -11759,10 +11943,14 @@ export async function startLocalServer(opts) {
                                 owner: parsed.owner,
                                 tags: parsed.tags,
                             });
+                            if (result.preview)
+                                writeBlockStudioRunSummary(projectRoot, savedPath, certifiedSource, result.preview.result);
                             certifiedPayload = openBlockStudioDocument(projectRoot, savedPath, semanticLayer);
                         }
                         else {
                             setBlockStudioStatus(projectRoot, normalizedBlockPath, 'certified');
+                            if (result.preview)
+                                writeBlockStudioRunSummary(projectRoot, normalizedBlockPath, certifiedSource, result.preview.result);
                             certifiedPayload = openBlockStudioDocument(projectRoot, normalizedBlockPath, semanticLayer);
                         }
                     }
@@ -11802,7 +11990,7 @@ export async function startLocalServer(opts) {
                         source: certifiedPayload?.source ?? certifiedSource,
                         metadata: certifiedPayload?.metadata,
                         companionPath: certifiedPayload?.companionPath ?? null,
-                        validation: certifiedPayload?.validation ?? result.validation,
+                        validation: result.validation,
                         lineageRefresh: { status: 'queued', operationId: refreshOperation.id },
                     }));
                 }
@@ -12337,13 +12525,14 @@ export async function startLocalServer(opts) {
                             }));
                             return;
                         }
+                        const reusableSource = markBlockStudioSourceReusable(readiness.candidate.dqlSource);
                         const savedPath = saveBlockStudioArtifacts(projectRoot, {
-                            source: readiness.candidate.dqlSource,
+                            source: reusableSource,
                             name: readiness.candidate.name,
                             domain: readiness.candidate.domain,
                             description: readiness.candidate.description,
                             owner: readiness.candidate.owner,
-                            tags: readiness.candidate.tags,
+                            tags: Array.from(new Set([...readiness.candidate.tags, APP_SOURCE_REUSABLE_TAG])),
                             lineage: readiness.candidate.lineage.sourceTables,
                             importMeta: {
                                 importId,
@@ -12352,7 +12541,13 @@ export async function startLocalServer(opts) {
                                 sourcePath: readiness.candidate.sourcePath,
                             },
                         });
-                        const next = { ...readiness.candidate, reviewStatus: 'saved', savedPath };
+                        const next = {
+                            ...readiness.candidate,
+                            dqlSource: reusableSource,
+                            tags: Array.from(new Set([...readiness.candidate.tags, APP_SOURCE_REUSABLE_TAG])),
+                            reviewStatus: 'saved',
+                            savedPath,
+                        };
                         writeBlockStudioImportCandidate(projectRoot, importId, next);
                         await refreshLocalMetadataCatalog(projectRoot);
                         const payload = openBlockStudioDocument(projectRoot, savedPath, semanticLayer);
@@ -12568,15 +12763,26 @@ export async function startLocalServer(opts) {
                         ? body.parameters
                         : {};
                     const preview = await runBlockStudioPreviewSource(source, targetConnection, parameters);
+                    const blockPath = typeof body.path === 'string' ? body.path : null;
+                    if (blockPath)
+                        writeBlockStudioRunSummary(projectRoot, blockPath, source, preview.result);
                     res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                     res.end(serializeJSON(preview));
                 }
                 catch (error) {
                     const raw = error instanceof Error ? error.message : String(error);
+                    const friendlyMessage = compactBlockStudioRuntimeFailure(raw);
                     res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
-                    // `error` stays the full compiler output (the UI shows it in a
-                    // collapsible); `friendlyMessage` is the one actionable sentence.
-                    res.end(serializeJSON({ error: raw, friendlyMessage: compactSemanticRuntimeFailure(raw) }));
+                    // Keep the result surface concise. Raw compiler output remains available
+                    // for support and AI repair, but is never the primary end-user message.
+                    res.end(serializeJSON({
+                        error: raw,
+                        friendlyMessage,
+                        code: 'BLOCK_PREVIEW_FAILED',
+                        recoverable: true,
+                        details: { technicalDetails: raw },
+                        nextActions: ['Review the named field or metric.', 'Fix the draft and run it again.'],
+                    }));
                 }
                 return;
             }
@@ -12584,7 +12790,7 @@ export async function startLocalServer(opts) {
                 try {
                     const body = await readJSON(req);
                     const source = typeof body.source === 'string'
-                        ? sanitizeAgentBlockDraftSource(body.source)
+                        ? markBlockStudioSourceReusable(sanitizeAgentBlockDraftSource(body.source))
                         : '';
                     const name = typeof body.name === 'string' ? body.name.trim() : '';
                     if (!source.trim() || !name) {
@@ -12597,7 +12803,10 @@ export async function startLocalServer(opts) {
                         name,
                         domain: typeof body.domain === 'string' ? body.domain : undefined,
                         description: typeof body.description === 'string' ? body.description : undefined,
-                        tags: Array.isArray(body.tags) ? body.tags.map(String) : ['ai-generated', 'review-required'],
+                        tags: Array.from(new Set([
+                            ...(Array.isArray(body.tags) ? body.tags.map(String) : ['ai-generated', 'review-required']),
+                            APP_SOURCE_REUSABLE_TAG,
+                        ])),
                         stableSuffix: typeof body.runId === 'string' ? body.runId : undefined,
                     });
                     const payload = openBlockStudioDocument(projectRoot, savedPath, semanticLayer);
@@ -12613,7 +12822,9 @@ export async function startLocalServer(opts) {
             if (req.method === 'POST' && path === '/api/block-studio/save') {
                 try {
                     const body = await readJSON(req);
-                    const source = typeof body.source === 'string' ? body.source : '';
+                    const source = typeof body.source === 'string'
+                        ? markBlockStudioSourceReusable(body.source)
+                        : '';
                     const metadata = body.metadata && typeof body.metadata === 'object'
                         ? body.metadata
                         : {};
@@ -12650,7 +12861,10 @@ export async function startLocalServer(opts) {
                         folderPath: metadata.folderPath,
                         description: metadata.description,
                         owner: metadata.owner,
-                        tags: Array.isArray(metadata.tags) ? metadata.tags.map(String) : [],
+                        tags: Array.from(new Set([
+                            ...(Array.isArray(metadata.tags) ? metadata.tags.map(String) : []),
+                            APP_SOURCE_REUSABLE_TAG,
+                        ])),
                         lineage: Array.isArray(metadata.lineage) ? metadata.lineage.map(String) : undefined,
                         importMeta: metadata.sourceKind || metadata.sourcePath || metadata.importId || metadata.candidateId
                             ? {
@@ -16240,7 +16454,8 @@ function resolveDashboardItemBlock(item, manifest) {
         return manifest.blocks[item.block.blockId] ?? null;
     }
     const normalizedRef = normalize(item.block.ref).replaceAll('\\', '/');
-    return Object.values(manifest.blocks).find((b) => normalize(b.filePath).replaceAll('\\', '/') === normalizedRef) ?? null;
+    return (manifest.blockDeclarations ?? Object.values(manifest.blocks))
+        .find((b) => normalize(b.filePath).replaceAll('\\', '/') === normalizedRef) ?? null;
 }
 function mergeDashboardChartConfig(base, item) {
     const options = item.viz.options ?? {};
@@ -20708,7 +20923,62 @@ export function openBlockStudioDocument(projectRoot, relativePath, semanticLayer
         metadata,
         companionPath: companionPath && existsSync(join(projectRoot, companionPath)) ? companionPath : null,
         validation: validateBlockStudioSource(source, semanticLayer),
+        lastRun: readBlockStudioRunSummary(projectRoot, normalizedPath, source) ?? undefined,
+    };
+}
+function blockStudioExecutionFingerprint(source) {
+    return createHash('sha256')
+        .update(setBlockStudioStatusInSource(source, 'draft').trim())
+        .digest('hex');
+}
+function blockStudioRunSummaryPath(projectRoot, blockPath) {
+    const normalizedPath = normalize(blockPath).replace(/^\/+/, '').replaceAll('\\', '/');
+    const pathKey = createHash('sha256').update(normalizedPath).digest('hex').slice(0, 32);
+    return join(projectRoot, '.dql', 'runs', 'block-studio', `${pathKey}.json`);
+}
+function writeBlockStudioRunSummary(projectRoot, blockPath, source, result) {
+    const normalizedPath = normalize(blockPath).replace(/^\/+/, '').replaceAll('\\', '/');
+    if (!isBlockStudioBlockPath(normalizedPath))
+        return;
+    const receiptPath = blockStudioRunSummaryPath(projectRoot, normalizedPath);
+    mkdirSync(dirname(receiptPath), { recursive: true });
+    const receipt = {
+        version: 1,
+        blockPath: normalizedPath,
+        sourceFingerprint: blockStudioExecutionFingerprint(source),
+        rowCount: result.rowCount ?? result.rows.length,
+        executionTime: result.executionTime,
+        columns: result.columns,
+        ranAt: new Date().toISOString(),
     };
+    const tempPath = `${receiptPath}.${process.pid}.tmp`;
+    writeFileSync(tempPath, JSON.stringify(receipt, null, 2) + '\n', 'utf-8');
+    renameSync(tempPath, receiptPath);
+}
+function readBlockStudioRunSummary(projectRoot, blockPath, source) {
+    try {
+        const normalizedPath = normalize(blockPath).replace(/^\/+/, '').replaceAll('\\', '/');
+        const receiptPath = blockStudioRunSummaryPath(projectRoot, normalizedPath);
+        if (!existsSync(receiptPath))
+            return null;
+        const receipt = JSON.parse(readFileSync(receiptPath, 'utf-8'));
+        if (receipt.version !== 1
+            || receipt.blockPath !== normalizedPath
+            || receipt.sourceFingerprint !== blockStudioExecutionFingerprint(source)
+            || !Number.isFinite(receipt.rowCount)
+            || !Array.isArray(receipt.columns)
+            || typeof receipt.ranAt !== 'string')
+            return null;
+        return {
+            rowCount: Number(receipt.rowCount),
+            executionTime: typeof receipt.executionTime === 'number' ? receipt.executionTime : undefined,
+            columns: receipt.columns.filter((column) => typeof column === 'string'),
+            ranAt: receipt.ranAt,
+        };
+    }
+    catch {
+        return null;
+    }
 }
 const BLOCK_STUDIO_DRAFT_RUNTIME_DIAGNOSTICS = new Set([
     'metricflow_unavailable',
@@ -20716,6 +20986,161 @@ const BLOCK_STUDIO_DRAFT_RUNTIME_DIAGNOSTICS = new Set([
     'semantic_layer_missing',
     'semantic_runtime_required',
 ]);
+const BLOCK_STUDIO_RUNTIME_COMPILE_DIAGNOSTICS = new Set([
+    'metricflow_unavailable',
+    'semantic_compose_failed',
+    'semantic_layer_missing',
+    'semantic_runtime_check_required',
+    'semantic_runtime_required',
+]);
+function staticSemanticAuthoringDiagnostic(diagnostic) {
+    if (!BLOCK_STUDIO_RUNTIME_COMPILE_DIAGNOSTICS.has(diagnostic.code ?? ''))
+        return diagnostic;
+    return {
+        severity: 'warning',
+        code: 'semantic_runtime_check_required',
+        title: 'Run required for semantic validation',
+        field: 'Runtime',
+        message: 'The block structure and references are valid, but only the configured semantic runtime can prove this metric combination.',
+        correction: 'Run the block to validate compilation and data access before certification.',
+        technicalDetails: diagnostic.message,
+        action: 'run_again',
+    };
+}
+function presentBlockStudioDiagnostic(diagnostic, semanticRefs) {
+    if (diagnostic.title || diagnostic.correction)
+        return diagnostic;
+    const raw = diagnostic.message.trim();
+    const locationMatch = /(?:line\s+)?(\d+)[: ,]+(?:column\s+)?(\d+)/i.exec(raw);
+    const technicalDetails = raw.length > 300 || raw.includes('\n') ? raw : undefined;
+    const base = {
+        ...diagnostic,
+        ...(technicalDetails ? { technicalDetails } : {}),
+        ...(locationMatch ? { location: { line: Number(locationMatch[1]), column: Number(locationMatch[2]) } } : {}),
+    };
+    switch (diagnostic.code) {
+        case 'semantic_compose_failed':
+            return {
+                ...base,
+                title: 'Selected metrics cannot be compiled',
+                field: 'Metrics',
+                references: semanticRefs.metrics,
+                message: semanticRefs.metrics.length > 0
+                    ? `${semanticRefs.metrics.length} selected metric${semanticRefs.metrics.length === 1 ? '' : 's'} could not be compiled by the configured semantic runtime.`
+                    : 'The selected metrics and dimensions do not share a governed query path.',
+                correction: 'Review the listed metrics in Modeling. Add the missing governed measure or relationship metadata, or replace the incompatible metric, then run the block again.',
+                technicalDetails: raw,
+                action: 'review_metrics',
+            };
+        case 'metricflow_unavailable':
+        case 'semantic_runtime_required':
+        case 'semantic_layer_missing':
+            return {
+                ...base,
+                title: 'Semantic runtime is not ready',
+                field: 'Runtime',
+                references: semanticRefs.metrics,
+                message: 'This semantic block needs a configured dbt Cloud, local MetricFlow, or DQL semantic runtime before it can run or be certified.',
+                correction: 'Open semantic runtime settings, connect the project runtime, then run the block again.',
+                technicalDetails: raw,
+                action: 'configure_runtime',
+            };
+        case 'semantic_metric_missing':
+            return {
+                ...base,
+                title: 'Choose at least one metric',
+                field: 'Metrics',
+                message: 'This semantic block does not select a metric yet.',
+                correction: 'Add one or more governed metrics in the visual builder or DQL source.',
+                action: 'review_metrics',
+            };
+        case 'semantic_ref': {
+            const reference = raw.split(':').slice(1).join(':').trim();
+            return {
+                ...base,
+                title: 'Semantic reference was not found',
+                field: 'Metrics and dimensions',
+                references: reference ? [reference] : [...semanticRefs.metrics, ...semanticRefs.dimensions],
+                message: reference ? `“${reference}” is not available in the current semantic snapshot.` : compactSemanticRuntimeFailure(raw),
+                correction: 'Choose a current metric or dimension from the semantic catalog, then run validation again.',
+                action: 'review_metrics',
+            };
+        }
+        case 'semantic_granularity_missing':
+            return {
+                ...base,
+                title: 'Choose a time grain',
+                field: 'Time',
+                message: 'A time dimension is selected without a granularity.',
+                correction: 'Choose day, week, month, quarter, or year for the selected time dimension.',
+                action: 'review_metrics',
+            };
+        case 'parameter_parse':
+            return {
+                ...base,
+                title: 'Run input is invalid',
+                field: 'Parameters',
+                message: compactSemanticRuntimeFailure(raw),
+                correction: 'Correct the named parameter, default value, or binding, then run validation again.',
+                action: 'edit_parameters',
+            };
+        case 'syntax':
+        case 'semantic_shape':
+        case 'semantic_block_has_query':
+        case 'sql_missing':
+        case 'sql_read_only':
+            return {
+                ...base,
+                title: diagnostic.code === 'sql_read_only' ? 'Only read-only SQL is allowed' : 'DQL source needs attention',
+                field: 'DQL source',
+                message: compactSemanticRuntimeFailure(raw),
+                correction: diagnostic.code === 'sql_read_only'
+                    ? 'Replace write or DDL statements with one read-only query.'
+                    : 'Open DQL source, correct the highlighted declaration, then validate again.',
+                action: 'edit_source',
+            };
+        default:
+            return base;
+    }
+}
+export function compactBlockStudioRuntimeFailure(failure) {
+    const semanticPrefix = 'Could not compose SQL for semantic block metrics.';
+    const semanticIndex = failure.indexOf(semanticPrefix);
+    if (semanticIndex >= 0) {
+        const remainder = failure.slice(semanticIndex + semanticPrefix.length);
+        const references = Array.from(remainder.matchAll(/(?:^|\s)([A-Za-z_][\w.:/-]*)\s*:/g), (match) => match[1]);
+        const uniqueReferences = Array.from(new Set(references));
+        if (uniqueReferences.length > 0) {
+            return `${uniqueReferences.length} selected metric${uniqueReferences.length === 1 ? '' : 's'} cannot be compiled by the current semantic runtime: ${uniqueReferences.join(', ')}. Review the measure and relationship metadata, then run again.`;
+        }
+        return 'The selected metrics and dimensions do not share a governed query path. Review the semantic relationships, then run again.';
+    }
+    return compactSemanticRuntimeFailure(failure);
+}
+function presentBlockStudioDiagnostics(diagnostics, semanticRefs) {
+    return diagnostics.map((diagnostic) => presentBlockStudioDiagnostic(diagnostic, semanticRefs));
+}
+/**
+ * Certification and preview must use the same compiler verdict. A successful
+ * dbt/MetricFlow compile supersedes the native compiler's capability warning;
+ * syntax, unsafe SQL, unknown references, and parameter errors remain intact.
+ */
+export function reconcileBlockStudioRuntimeValidation(validation, runtime) {
+    const diagnostics = [
+        ...validation.diagnostics.filter((diagnostic) => !BLOCK_STUDIO_RUNTIME_COMPILE_DIAGNOSTICS.has(diagnostic.code ?? '')),
+        ...runtime.diagnostics,
+    ].filter((diagnostic, index, all) => all.findIndex((candidate) => (candidate.severity === diagnostic.severity
+        && candidate.code === diagnostic.code
+        && candidate.message === diagnostic.message)) === index);
+    const presented = presentBlockStudioDiagnostics(diagnostics, validation.semanticRefs);
+    return {
+        ...validation,
+        valid: presented.every((diagnostic) => diagnostic.severity !== 'error'),
+        saveable: blockStudioValidationAllowsDraftSave({ diagnostics: presented }),
+        diagnostics: presented,
+        executableSql: runtime.sql ?? validation.executableSql,
+    };
+}
 /**
  * Draft persistence is stricter than loose text storage but does not require a
  * configured execution runtime. Syntax, unsafe SQL, invalid semantic identity,
@@ -21266,7 +21691,10 @@ export function validateBlockStudioSource(source, semanticLayer) {
         if (semanticLayer) {
             const semanticCompose = composeSemanticBlockSql(source, semanticLayer);
             semanticRefs = semanticCompose.semanticRefs;
-            diagnostics.push(...semanticCompose.diagnostics);
+            // Synchronous validation owns authored shape, references, safety, and
+            // parameter contracts. A native compile miss is not an authoring error:
+            // dbt Cloud or MetricFlow may compile the exact same source successfully.
+            diagnostics.push(...semanticCompose.diagnostics.map(staticSemanticAuthoringDiagnostic));
             executableSql = semanticCompose.sql;
         }
         else {
@@ -21352,10 +21780,11 @@ export function validateBlockStudioSource(source, semanticLayer) {
             });
         }
     }
+    const presentedDiagnostics = presentBlockStudioDiagnostics(diagnostics, semanticRefs);
     return {
-        valid: diagnostics.every((diagnostic) => diagnostic.severity !== 'error'),
-        saveable: blockStudioValidationAllowsDraftSave({ diagnostics }),
-        diagnostics,
+        valid: presentedDiagnostics.every((diagnostic) => diagnostic.severity !== 'error'),
+        saveable: blockStudioValidationAllowsDraftSave({ diagnostics: presentedDiagnostics }),
+        diagnostics: presentedDiagnostics,
         semanticRefs,
         chartConfig: chartConfig ?? undefined,
         executableSql,
@@ -21363,14 +21792,18 @@ export function validateBlockStudioSource(source, semanticLayer) {
     };
 }
 export async function createDqlArtifactGenerationSessionForProject(projectRoot, options, semanticLayer) {
-    const dqlArtifact = normalizeDqlArtifactReference(options.dqlArtifact);
-    if (!dqlArtifact)
+    const normalizedDqlArtifact = normalizeDqlArtifactReference(options.dqlArtifact);
+    if (!normalizedDqlArtifact)
         throw new Error('A DQL artifact with source is required for DQL draft promotion.');
+    const dqlArtifact = {
+        ...normalizedDqlArtifact,
+        source: markBlockStudioSourceReusable(normalizedDqlArtifact.source),
+    };
     const question = notebookResearchString(options.question) ?? dqlArtifact.name ?? 'Generated DQL artifact';
     const slug = deriveGeneratedDraftSlug(dqlArtifact.name ?? question);
     const domain = notebookResearchString(options.domain) ?? 'misc';
     const owner = notebookResearchString(options.owner) ?? '';
-    const tags = Array.from(new Set(['notebook-research', 'review-required', 'dql-artifact', ...(Array.isArray(options.tags) ? options.tags : [])]
+    const tags = Array.from(new Set(['notebook-research', 'review-required', 'dql-artifact', APP_SOURCE_REUSABLE_TAG, ...(Array.isArray(options.tags) ? options.tags : [])]
         .map((tag) => notebookResearchString(tag))
         .filter((tag) => Boolean(tag))));
     const proposedContractId = `${domain}.Unknown.${slug}`;
@@ -22264,6 +22697,23 @@ export function parseBlockSourceMetadata(source) {
         metricsRef: extractStringArray('metrics'),
     };
 }
+/**
+ * Persist the explicit App-source reuse decision in canonical DQL. Generated
+ * execution stays transient; only Block Studio save/promotion routes call this
+ * helper. The marker is a normal parser-supported tag, so refresh/reindex can
+ * make the participation decision without relying on filenames or prose.
+ */
+export function markBlockStudioSourceReusable(source) {
+    const parsed = parseBlockSourceMetadata(source);
+    if (parsed.tags.some((tag) => tag.trim().toLowerCase() === APP_SOURCE_REUSABLE_TAG))
+        return source;
+    const tags = Array.from(new Set([...parsed.tags, APP_SOURCE_REUSABLE_TAG]));
+    const rendered = tags.map((tag) => JSON.stringify(tag)).join(', ');
+    if (/\btags\s*=\s*\[[\s\S]*?\]/i.test(source)) {
+        return source.replace(/\btags\s*=\s*\[[\s\S]*?\]/i, `tags = [${rendered}]`);
+    }
+    return source.replace(/(\bblock\s+"[^"]+"\s*\{)/i, `$1\n  tags = [${rendered}]`);
+}
 function compareBlockStudioValues(actual, operator, expected) {
     const expectedValue = normalizeBlockStudioExpected(expected);
     if (operator === '==' || operator === '=')
@@ -22339,22 +22789,88 @@ function evaluateBlockStudioTests(tests, rows, columns, startedAt) {
 function buildBlockStudioCertificationChecklist(input) {
     const parsed = parseBlockSourceMetadata(input.source);
     const sql = extractBlockStudioSql(input.source) ?? '';
-    const blockers = new Set();
-    for (const diagnostic of input.validation.diagnostics) {
-        if (diagnostic.severity === 'error')
-            blockers.add(diagnostic.message);
-    }
-    for (const error of input.certificationErrors)
-        blockers.add(`${error.rule}: ${error.message}`);
-    for (const blocker of input.extraBlockers ?? [])
-        blockers.add(blocker);
-    if (!input.previewSucceeded)
-        blockers.add('Block has not run successfully');
+    const issues = input.validation.diagnostics
+        .filter((diagnostic) => diagnostic.severity === 'error');
+    for (const error of input.certificationErrors) {
+        const combined = `${error.rule}: ${error.message}`;
+        const lower = combined.toLowerCase();
+        if (lower.includes('missing owner')) {
+            issues.push({
+                severity: 'error',
+                code: 'owner_missing',
+                title: 'Add an owner',
+                field: 'Metadata',
+                message: 'Owner is required before certification.',
+                correction: 'Enter the accountable team or person in Metadata, save the draft, and certify again.',
+                action: 'edit_source',
+                technicalDetails: combined,
+            });
+        }
+        else if (lower.includes('tests pass')) {
+            issues.push({
+                severity: 'error',
+                code: 'tests_failed',
+                title: 'A block test failed',
+                field: 'Tests',
+                message: 'One or more declared tests did not pass against the latest preview result.',
+                correction: 'Review the failed assertion and result, correct the query or expectation, then run certification again.',
+                action: 'edit_source',
+                technicalDetails: combined,
+            });
+        }
+        else {
+            issues.push({
+                severity: 'error',
+                code: `certification_${error.rule.toLowerCase().replace(/[^a-z0-9]+/g, '_')}`,
+                title: 'Certification requirement is not ready',
+                field: 'Metadata',
+                message: compactSemanticRuntimeFailure(combined),
+                correction: 'Update the named block field, save the draft, and certify again.',
+                action: 'edit_source',
+                technicalDetails: combined,
+            });
+        }
+    }
+    for (const blocker of input.extraBlockers ?? []) {
+        issues.push({
+            severity: 'error',
+            code: 'preview_failed',
+            title: 'Preview did not finish',
+            field: 'Run',
+            message: compactBlockStudioRuntimeFailure(blocker),
+            correction: 'Correct the reported query or runtime problem, then run the block again before certification.',
+            technicalDetails: blocker,
+            action: 'run_again',
+        });
+    }
+    if (!input.previewSucceeded && (input.extraBlockers?.length ?? 0) === 0) {
+        issues.push({
+            severity: 'error',
+            code: 'preview_required',
+            title: 'Run the block',
+            field: 'Run',
+            message: 'The block needs a successful preview result before certification.',
+            correction: 'Run the block, resolve any preview error, then certify again.',
+            action: 'run_again',
+        });
+    }
     // Only a REAL test failure blocks. "No tests" and "no chart" are advisory review
     // items the AI fills at draft time — never hard gates (owner is the gate). This is
     // what keeps "build a DQL" from demanding ~13 fields per block at 300-query scale.
-    if (input.testResults && input.testResults.failed > 0)
-        blockers.add('Tests must pass before certification');
+    if (input.testResults && input.testResults.failed > 0 && !issues.some((issue) => issue.code === 'tests_failed')) {
+        issues.push({
+            severity: 'error',
+            code: 'tests_failed',
+            title: 'A block test failed',
+            field: 'Tests',
+            message: 'One or more declared tests did not pass against the latest preview result.',
+            correction: 'Review the failed assertion and result, correct the query or expectation, then run certification again.',
+            action: 'edit_source',
+        });
+    }
+    const uniqueIssues = issues.filter((issue, index, all) => all.findIndex((candidate) => (candidate.code === issue.code
+        && candidate.message === issue.message
+        && (candidate.references ?? []).join('|') === (issue.references ?? []).join('|'))) === index);
     return {
         // The metadata tab is green once the one required field (owner) is present.
         // Description/domain are AI-filled + editable and surface as review items, not gates.
@@ -22365,7 +22881,8 @@ function buildBlockStudioCertificationChecklist(input) {
         chart: Boolean(input.validation.chartConfig?.chart),
         lineage: extractSqlTablesLight(sql).length > 0 || input.validation.semanticRefs.metrics.length > 0,
         aiReviewed: true,
-        blockers: Array.from(blockers),
+        blockers: uniqueIssues.map((issue) => issue.message),
+        issues: uniqueIssues,
         checkedAt: new Date().toISOString(),
     };
 }