@duckcodeailabs/dql-cli 1.13.1 → 1.13.3

package/dist/local-runtime.js

@@ -15,7 +15,7 @@ import { buildMixedSourceWarehouseFallbackSql, findMentionedNotebookDataset, pla
 import { resolveNpmInvocation } from './npm-runtime.js';
 import { ensureDqlGitignore, isGovernedSourceFile, isLegacyBroadDqlIgnore, } from './git-contract.js';
 import { buildExecutionPlan, createWelcomeNotebook, deserializeNotebook, getConnectorFormSchemas, hasSemanticRefs, hasStandaloneSemanticRef, resolveSemanticRefs, } from '@duckcodeailabs/dql-notebook';
-import { loadSemanticLayerFromDir, normalizeDqlArtifactReference, serializeMetricDefinitionToYaml, resolveSemanticLayerAsync, resolveRepoSource, getDialect, Parser, NodeKind, blockParameterDefinitions, buildLineageGraph, buildManifest, collectInputFiles, findAppDocuments, findDashboardsForApp, isBlockIdRef, loadAppDocument, loadDashboardDocument, analyzeImpact, buildTrustChain, detectDomainFlows, getDomainTrustOverview, queryLineage, queryBusiness360, queryCompleteLineagePaths, LineageGraph, canonicalize, canonicalizeNotebook, diffDQL, diffNotebook, domainFolderSlug, previewModelingChange, previewModelingChanges, applyModelingChange, previewDbtSourcePatch, applyDbtSourcePatch, loadDomainPackageRegistry, loadDbtNodeAuthoringDetail, normalizeAnalyticalFailureV1, relationshipValidationProofFingerprint, renderSemanticBlockSource, discoverDbtDomains, renderDomainDeclaration, ProjectSnapshotService, analyzeSqlReferences, semanticDimensionReference, } from '@duckcodeailabs/dql-core';
+import { loadSemanticLayerFromDir, normalizeDqlArtifactReference, serializeMetricDefinitionToYaml, resolveSemanticLayerAsync, resolveRepoSource, getDialect, Parser, NodeKind, blockParameterDefinitions, buildLineageGraph, buildManifest, collectInputFiles, findAppDocuments, findDashboardsForApp, isBlockIdRef, loadAppDocument, loadDashboardDocument, analyzeImpact, buildTrustChain, detectDomainFlows, getDomainTrustOverview, queryLineage, queryBusiness360, queryCompleteLineagePaths, LineageGraph, canonicalize, canonicalizeNotebook, diffDQL, diffNotebook, domainFolderSlug, previewModelingChange, previewModelingChanges, applyModelingChange, previewDbtSourcePatch, applyDbtSourcePatch, loadDomainPackageRegistry, loadDbtNodeAuthoringDetail, normalizeAnalyticalFailureV1, relationshipValidationProofFingerprint, renderSemanticBlockSource, discoverDbtDomains, collectDbtRelationshipTests, renderDomainDeclaration, ProjectSnapshotService, analyzeSqlReferences, semanticDimensionReference, modelAreaLocalId, DEFAULT_MODEL_AREA_ID, } from '@duckcodeailabs/dql-core';
 import { load as loadYaml } from 'js-yaml';
 import { listBlockTemplates } from './block-templates.js';
 import { getRunner as getLLMRunner } from './llm/index.js';
@@ -25,7 +25,7 @@ import { resolveRetrievalHealthStatus } from './retrieval-health.js';
 import { createDqlAgentProviderRunner, resolveAgentFollowUpContext } from './llm/providers/dql-agent-provider.js';
 import { listRemoteMcpSettings, saveRemoteMcpSettings } from './llm/mcp-config.js';
 import { ClaudeProvider, ConversationStore, advanceThreadState, buildConversationSnapshot, conversationHistoryFromContext, recallRelevantTurns, renderConversationEnvelopeForPrompt, GeminiProvider, MemoryStore, OllamaProvider, OpenAIProvider, buildBlockBusinessFingerprint, buildBlockSqlFingerprints, buildAnalysisQuestionPlan, composeSemanticQueryForQuestion, aggregationIntegrityIssuesForSql, buildLocalContextPack, applyContextPackCompatibility, toAgentRetrievalEvidence, prepareConversationPath, defaultMemoryPath, ensureDefaultMemoryFiles, ensureAgentProjectReady, isAgentProjectIndexReady, currentMetadataFingerprint, ensureMetadataCatalogFresh, readIndexedDomainKnowledge, readIndexedKnowledge360, compactSemanticRuntimeFailure, classifyAnalyticalFailure, normalizeWarehouseSqlFailure, parseProposal, propose, proposePlan, recordGovernedCorrection, HintStore, defaultHintIndexPath, ensureHintIndexFresh, listHintsFromGit, getHintEvaluationFromGit, getCorrectionTraceFromGit, inspectGovernedHint, editGovernedHintCandidate, reopenGovernedHint, retireHint, supersedeHint, hintsConflict, mineJoinPatterns, reviewGovernedHint, AgentRunEngine, SqliteAgentRunStore, defaultAgentRunGates, createLlmAgentRunPlanner, createHybridRouter, computeResultStats, buildDeterministicDashboardStory, synthesizeAnswer, streamOrGenerate, narrateResult, buildProposePreview, buildFromPrompt, internalRelationIdsInSql, defaultAgentRunStorePath, defaultAgentRunSqlitePath, resolveLocalOwner, resolveProposeConfig, recordQueryRun, recordRuntimeSchemaSnapshot, latestRuntimeSchemaSnapshotForProject, loadSkills, migrateLegacySkills, configuredSkillsPath, skillsDir, draftDomainSkillBootstrap, buildDomainSkillBootstrapPrompt, mergeDomainSkillBootstrapEnrichment, writeSkill, previewSkillChange, buildContextAuthoringProposal, contextAuthoringDependencyClosure, FileContextAuthoringProposalStore, deleteSkill, deriveGeneratedDraftSlug, deriveAnalyticalRepair, reindexProject, invalidateAgentProjectState, recordAgentRuntimeVersion, resolveDomainContextEnvelope, projectEmbeddingProvider, isHashedEmbeddingProvider, clearProjectEmbeddingCache, upgradeVectorIndexForProject, openMetadataCatalog, defaultKgPath, planAppFromPrompt, KGStore, planResearch, loadSemanticMetrics, cascadeTraceToEvidenceRouteSteps, createCascadeAnswerResult, createCascadeTrace, routeReasoningEffort, routeForCascadeAnswerTier, clampReasoningEffort, bumpReasoningEffort, resolveThinkingMode, coerceThinkingMode, upsertGeneratedDqlArtifactDraft, loadAgentSemanticLayer, isTrustedConversationTurn, resolveInternalRelationIds, analyticalError, tagAnalyticalError, withAnalyticalErrorOrigin, withAnalyticalErrorOriginSync, } from '@duckcodeailabs/dql-agent';
-import { addSqlResultFilter, filterableResultColumns, replaceBlockStudioSql } from './sql-result-filter.js';
+import { addSqlResultFilter, dashboardFilterableResultColumns, filterableResultColumns, replaceBlockStudioSql } from './sql-result-filter.js';
 import { gatherProposeEnrichment } from './propose-enrich.js';
 import { handleAppsApi, proposeAppAiBuild, recommendVisualization, } from './apps-api.js';
 import { getActiveProvider, getEffectiveProviderConfig, isProviderSettingsId, listProviderSettings, saveProviderSettings, } from './settings/provider-settings.js';
@@ -87,7 +87,16 @@ function hasDbtSemanticArtifacts(projectRoot, dbtProjectDir, configuredManifestP
     }
     return false;
 }
-const AGENT_RUN_REQUESTED_MODES = new Set(['auto', 'ask', 'research', 'sql', 'block', 'app']);
+// Every member of `AgentRunRequestedMode`. The `Record` (rather than a bare
+// Set literal) is deliberate: a `Set<AgentRunRequestedMode>` happily accepts a
+// subset, which is how 'modeling' and 'skill' went missing here — the parser
+// dropped them to `undefined`, `selectRoute` never saw an explicit mode, and
+// Modeling AI silently ran the governed answer loop instead of proposing a
+// model. A Record makes an omission a compile error.
+const AGENT_RUN_REQUESTED_MODE_MEMBERS = {
+    auto: true, ask: true, research: true, sql: true, block: true, app: true, modeling: true, skill: true,
+};
+const AGENT_RUN_REQUESTED_MODES = new Set(Object.keys(AGENT_RUN_REQUESTED_MODE_MEMBERS));
 /** AGT-007 / AGT-022: App-specific context adapter into the uniform AgentRun. */
 export function buildAppCopilotResearchAgentRequest(input) {
     const memoOnly = input.mode === 'memo_only';
@@ -959,6 +968,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);
@@ -1503,59 +1542,6 @@ export async function startLocalServer(opts) {
         });
         return { domainContext, contextPack };
     };
-    const buildAgentPromptArtifact = async (request, target, repair) => {
-        try {
-            await reindexProject(projectRoot, { kgPath: defaultKgPath(projectRoot) });
-        }
-        catch {
-            // Best-effort: buildFromPrompt can still use any existing KG/cache state.
-        }
-        const skills = loadSkills(projectRoot).skills;
-        // On a repair re-run, target the prior failure and (for blocks) revise in place.
-        const isRepair = (repair?.attempt ?? 0) > 0 && Boolean(repair?.repairHint);
-        const mode = target === 'block' && (isRepair || agentRunWorkspaceValue(request, 'mode') === 'edit')
-            ? 'edit'
-            : 'create';
-        const prompt = isRepair
-            ? `${request.question}\n\nFix the previous attempt: ${repair?.repairHint}`
-            : request.question;
-        const domain = target === 'block' ? agentRunWorkspaceValue(request, 'domain') : undefined;
-        const modelAreaId = agentRunWorkspaceValue(request, 'modelAreaId');
-        const purpose = agentRunWorkspaceValue(request, 'purpose');
-        const { domainContext, contextPack } = await buildDirectBuildContext({
-            question: prompt,
-            domain,
-            purpose,
-            modelAreaId,
-            surface: target === 'cell' ? 'notebook' : 'block',
-            selectedContext: { target, mode },
-        });
-        return buildFromPrompt({
-            projectRoot,
-            prompt,
-            context: {
-                cellSql: agentRunWorkspaceValue(request, 'cellSql'),
-                selection: agentRunWorkspaceValue(request, 'selection'),
-            },
-            target,
-            mode,
-            blockPath: target === 'block'
-                ? agentRunWorkspaceValue(request, 'blockPath')
-                    ?? (request.selectedObject?.kind === 'block' && request.selectedObject.path?.endsWith('.dql')
-                        ? request.selectedObject.path
-                        : undefined)
-                : undefined,
-            owner: agentRunWorkspaceValue(request, 'owner'),
-            domain,
-            modelAreaId,
-            contextPack,
-            domainContext,
-            userId: agentRunWorkspaceValue(request, 'userId'),
-            skills,
-            dbtManifestPath: resolveDbtManifestPath(projectRoot, projectConfig),
-            executionProbe: target === 'block' ? runBlockReflectionProbe : undefined,
-        });
-    };
     const agentRunEvaluation = (id, label, passed, severity, message, evidence) => ({ id, label, passed, severity, message, evidence });
     const agentRunArtifact = (kind, title, payload, ref, trustState = 'review_required') => ({
         id: `${kind}:${Date.now()}`,
@@ -2591,6 +2577,171 @@ export async function startLocalServer(opts) {
         };
     };
     const contextProposalStore = new FileContextAuthoringProposalStore(projectRoot);
+    /**
+     * UI-019: authoring must never dead-end on a Domain/Area that does not exist
+     * yet. Every modeling operation still belongs to exactly one Domain and Area
+     * (`11-context-authoring-and-ai.md`); the difference is that DQL now creates
+     * the missing scope as part of the same reviewable proposal instead of
+     * blocking the author until they create it by hand. The synthesized
+     * operations are ordinary reviewable patches, so nothing is written until the
+     * proposal is explicitly committed.
+     */
+    const ensureAuthoringScopeOperations = (operations, manifest) => {
+        const modeling = manifest.modeling;
+        if (!modeling)
+            return operations;
+        const existingDomains = new Set(Object.keys(modeling.packages ?? {}));
+        const existingAreas = new Set(Object.values(modeling.areas ?? {}).flatMap((area) => [`${area.domain}::${area.localId}`, `${area.domain}::${area.qualifiedId}`]));
+        // A scope created earlier in this same batch counts as existing.
+        for (const operation of operations) {
+            if (operation.kind !== 'modeling_change')
+                continue;
+            if (operation.change.operation === 'upsert_domain')
+                existingDomains.add(operation.change.value.id);
+            if (operation.change.operation === 'upsert_area')
+                existingAreas.add(`${operation.change.value.domain}::${operation.change.value.id}`);
+        }
+        const created = [];
+        const domainOperationId = new Map();
+        const areaOperationId = new Map();
+        const defaultAreaName = manifest.dbtProvenance?.projectName
+            ? titleCaseAuthoring(manifest.dbtProvenance.projectName)
+            : 'Core models';
+        const withScope = operations.map((operation) => {
+            if (operation.kind !== 'modeling_change')
+                return operation;
+            const change = operation.change;
+            if (change.operation !== 'upsert_entity' && change.operation !== 'upsert_relationship')
+                return operation;
+            const domain = change.value.domain;
+            if (!domain)
+                return operation;
+            const dependsOn = [...(operation.dependsOn ?? [])];
+            if (!existingDomains.has(domain)) {
+                let id = domainOperationId.get(domain);
+                if (!id) {
+                    id = `scope:domain:${domain}`;
+                    domainOperationId.set(domain, id);
+                    created.push({
+                        id,
+                        kind: 'modeling_change',
+                        evidence: ['created automatically so the requested modeling scope exists'],
+                        change: { operation: 'upsert_domain', value: { id: domain, name: titleCaseAuthoring(domain) } },
+                    });
+                }
+                if (!dependsOn.includes(id))
+                    dependsOn.push(id);
+            }
+            const areaId = change.value.areaId;
+            if (areaId && !existingAreas.has(`${domain}::${areaId}`)) {
+                const key = `${domain}::${areaId}`;
+                let id = areaOperationId.get(key);
+                if (!id) {
+                    id = `scope:area:${domain}:${areaId}`;
+                    areaOperationId.set(key, id);
+                    created.push({
+                        id,
+                        kind: 'modeling_change',
+                        dependsOn: domainOperationId.has(domain) ? [domainOperationId.get(domain)] : [],
+                        evidence: ['created automatically so the requested modeling scope exists'],
+                        change: {
+                            operation: 'upsert_area',
+                            value: {
+                                id: areaId,
+                                domain,
+                                name: areaId === DEFAULT_MODEL_AREA_ID ? defaultAreaName : titleCaseAuthoring(areaId),
+                                description: 'Subject area created automatically when modeling started. Rename or split it at any time.',
+                            },
+                        },
+                    });
+                }
+                if (!dependsOn.includes(id))
+                    dependsOn.push(id);
+            }
+            return dependsOn.length ? { ...operation, dependsOn } : operation;
+        });
+        return created.length ? [...created, ...withScope] : withScope;
+    };
+    /**
+     * REL-004: when a batch binds dbt models, bring across the relationships dbt
+     * already declares in its `relationships` tests. dbt states the exact key
+     * pair and `dbt test` enforces it, so redrawing those edges by hand is pure
+     * duplicated work.
+     *
+     * REL-001 is unchanged: a dbt test is evidence, not join authorization. Every
+     * edge produced here is `status: 'draft'` with `fanout: 'unknown'` and no
+     * validation receipt, so it can never prove an automatic join.
+     */
+    const appendDbtDeclaredRelationships = (operations, manifest) => {
+        const manifestPath = manifest.dbtProvenance?.manifestPath;
+        if (!manifestPath || !existsSync(manifestPath))
+            return operations;
+        // Entities this batch creates, plus entities already bound in the project.
+        const bound = new Map();
+        for (const entity of Object.values(manifest.modeling?.entities ?? {})) {
+            bound.set(entity.dbtUniqueId, { id: entity.localId, domain: entity.domain, areaId: modelAreaLocalId(entity.areaId) });
+        }
+        let batchBindings = 0;
+        for (const operation of operations) {
+            if (operation.kind !== 'modeling_change' || operation.change.operation !== 'upsert_entity')
+                continue;
+            const value = operation.change.value;
+            bound.set(value.dbtModel, { id: value.id, domain: value.domain, areaId: value.areaId, operationId: operation.id });
+            batchBindings += 1;
+        }
+        if (batchBindings === 0 || bound.size < 2)
+            return operations;
+        let rawManifest;
+        try {
+            rawManifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        }
+        catch {
+            return operations;
+        }
+        const existingRelationshipIds = new Set([
+            ...Object.values(manifest.modeling?.relationships ?? {}).map((relationship) => `${relationship.ownerDomain ?? ''}::${relationship.localId}`),
+            ...operations.flatMap((operation) => operation.kind === 'modeling_change' && operation.change.operation === 'upsert_relationship'
+                ? [`${operation.change.value.domain}::${operation.change.value.id}`]
+                : []),
+        ]);
+        const harvested = [];
+        for (const edge of collectDbtRelationshipTests(rawManifest, new Set(bound.keys()))) {
+            if (edge.fromColumn === 'unknown' || edge.toColumn === 'unknown')
+                continue;
+            const from = bound.get(edge.fromDbtUniqueId);
+            const to = bound.get(edge.toDbtUniqueId);
+            if (!from || !to || from.id === to.id)
+                continue;
+            // Only offer edges this batch actually introduces, and keep cross-domain
+            // links on the explicit export/import path.
+            if (!from.operationId && !to.operationId)
+                continue;
+            if (from.domain !== to.domain)
+                continue;
+            const id = `${from.id}_to_${to.id}`;
+            const key = `${from.domain}::${id}`;
+            if (existingRelationshipIds.has(key))
+                continue;
+            existingRelationshipIds.add(key);
+            harvested.push({
+                id: `dbt-test:${edge.testUniqueId}`,
+                kind: 'modeling_change',
+                dependsOn: [from.operationId, to.operationId].filter((value) => Boolean(value)),
+                evidence: [edge.testUniqueId, ...(edge.sourcePath ? [edge.sourcePath] : [])],
+                change: {
+                    operation: 'upsert_relationship',
+                    value: {
+                        id, domain: from.domain, areaId: from.areaId ?? to.areaId,
+                        from: from.id, to: to.id,
+                        keys: [{ from: edge.fromColumn, to: edge.toColumn }],
+                        cardinality: 'many_to_one', fanout: 'unknown', status: 'draft',
+                        rationale: `Declared by the dbt relationships test ${edge.testUniqueId}. Validate against the warehouse before certifying.`,
+                    },
+                },
+            });
+        }
+        return harvested.length ? [...operations, ...harvested] : operations;
+    };
     const previewContextAuthoring = (input) => {
         const snapshot = projectSnapshot();
         if (input.expectedSnapshotId && input.expectedSnapshotId !== snapshot.snapshotId) {
@@ -2637,30 +2788,48 @@ export async function startLocalServer(opts) {
             if (operation.change.operation === 'upsert_entity'
                 && (input.origin === 'ai' || input.origin === 'yaml_import' || input.origin === 'dbt_discovery')
                 && !operation.change.value.areaId) {
-                diagnostics.push({ code: 'MODEL_AREA_REQUIRED', severity: 'blocking', operationId: operation.id, message: 'Imported and AI-authored models must target one Model Area.' });
+                // Every model still belongs to exactly one Domain and subject area. An
+                // omitted area is filled with the default rather than blocking the
+                // author; `ensureAuthoringScopeOperations` creates it if it is new.
+                diagnostics.push({ code: 'MODEL_AREA_DEFAULTED', severity: 'info', operationId: operation.id, message: `No subject area was selected, so these models were placed in "${DEFAULT_MODEL_AREA_ID}". You can rename or move them later.` });
+                return { ...operation, change: { ...operation.change, value: { ...operation.change.value, areaId: DEFAULT_MODEL_AREA_ID } } };
             }
             return operation;
         });
-        const operationIds = new Set(operations.map((operation) => operation.id));
-        for (const operation of operations) {
+        // dbt discovery and Modeling AI bind models; give them the edges dbt already
+        // declares. Manual authoring and YAML import bring their own relationships.
+        const withDeclaredEdges = input.origin === 'dbt_discovery' || input.origin === 'ai'
+            ? appendDbtDeclaredRelationships(operations, snapshot.manifest)
+            : operations;
+        const scopedOperations = ensureAuthoringScopeOperations(withDeclaredEdges, snapshot.manifest);
+        const operationIds = new Set(scopedOperations.map((operation) => operation.id));
+        for (const operation of scopedOperations) {
             for (const dependency of operation.dependsOn ?? []) {
                 if (!operationIds.has(dependency))
                     diagnostics.push({ code: 'DEPENDENCY_CONFLICT', severity: 'blocking', operationId: operation.id, message: `Required proposal operation is missing: ${dependency}` });
             }
         }
         const patches = [];
-        const modelingOperations = operations.filter((operation) => operation.kind === 'modeling_change');
+        const modelingOperations = scopedOperations.filter((operation) => operation.kind === 'modeling_change');
         if (modelingOperations.length > 0) {
             const batch = previewModelingChanges(projectRoot, modelingOperations.map((operation) => operation.change));
+            // The batch attributes each path while composing its shadow, so a change
+            // that depends on an earlier one (an entity in a Domain this same batch
+            // creates) is attributed correctly and without re-previewing per patch.
+            const ownerByPath = new Map();
+            batch.patchPathsByChange.forEach((paths, index) => {
+                const operationId = modelingOperations[index]?.id;
+                if (!operationId)
+                    return;
+                for (const path of paths)
+                    if (!ownerByPath.has(path))
+                        ownerByPath.set(path, operationId);
+            });
             for (const patch of batch.patches) {
-                const owner = modelingOperations.find((operation) => {
-                    const single = previewModelingChange(projectRoot, operation.change);
-                    return single.patches.some((candidate) => candidate.path === patch.path);
-                })?.id ?? modelingOperations[0].id;
-                patches.push({ ...patch, owner: 'dql', operationId: owner });
+                patches.push({ ...patch, owner: 'dql', operationId: ownerByPath.get(patch.path) ?? modelingOperations[0].id });
             }
         }
-        for (const operation of operations) {
+        for (const operation of scopedOperations) {
             if (operation.kind === 'skill_change') {
                 const preview = previewSkillChange(projectRoot, operation.value, operation.targetQualifiedId, operation.expectedSourceHash);
                 for (const patch of preview.patches) {
@@ -2698,7 +2867,7 @@ export async function startLocalServer(opts) {
             origin: input.origin,
             baseSnapshotId: snapshot.snapshotId,
             dependencyFingerprints,
-            operations,
+            operations: scopedOperations,
             patches,
             diagnostics,
             sourceRunId: input.sourceRunId,
@@ -2710,34 +2879,75 @@ export async function startLocalServer(opts) {
     };
     const modelingAuthoringRunExecutor = async ({ runId, request }) => {
         const snapshot = projectSnapshot();
-        const operations = buildMetadataBoundModelingOperations(projectRoot, snapshot.manifest, request);
+        // AGT-024: a configured provider designs the model; the deterministic
+        // matcher is the documented provider-unavailable fallback, and the answer
+        // says which one ran so an evidence-only suggestion is never mistaken for
+        // an AI proposal.
+        const provider = await createBlockStudioAssistProvider(projectRoot);
+        let usedProvider = Boolean(provider);
+        let operations;
+        if (provider) {
+            try {
+                operations = await buildAiModelingOperations(projectRoot, snapshot.manifest, request, provider);
+            }
+            catch (error) {
+                // Fall back only when the provider itself is unusable. A rejected
+                // proposal (invented identifiers, nothing to propose) is a real result
+                // and must surface, not be papered over by the template matcher.
+                if (!/could not complete this modeling request/.test(error instanceof Error ? error.message : String(error)))
+                    throw error;
+                usedProvider = false;
+                operations = buildDeterministicModelingOperations(projectRoot, snapshot.manifest, request);
+            }
+        }
+        else {
+            operations = buildDeterministicModelingOperations(projectRoot, snapshot.manifest, request);
+        }
         const proposal = previewContextAuthoring({
             origin: request.workspaceContext?.correction === true ? 'correction' : 'ai',
             operations,
-            expectedSnapshotId: typeof request.workspaceContext?.snapshotId === 'string' ? request.workspaceContext.snapshotId : snapshot.snapshotId,
+            // Base the draft on the snapshot it was just built from, not on the id the
+            // client captured at page load. Gating construction on the client's id
+            // rejected a proposal assembled from `snapshot.manifest` moments earlier,
+            // so any unrelated project write (a block edit, a dbt reapply) made every
+            // Modeling AI request fail with PROPOSAL_STALE until a manual refresh.
+            // Drift is still caught where it matters: applying the proposal re-checks
+            // its `baseSnapshotId` and `dependencyFingerprints` and fails SOURCE_CHANGED.
+            expectedSnapshotId: snapshot.snapshotId,
             sourceRunId: runId,
             revision: Number(request.workspaceContext?.revision ?? 1),
         });
+        const blocked = proposal.diagnostics.some((item) => item.severity === 'blocking');
         return {
-            summary: `Prepared ${proposal.impact.modelingChanges} metadata-bound modeling change${proposal.impact.modelingChanges === 1 ? '' : 's'} for review.`,
-            answer: proposal.diagnostics.some((item) => item.severity === 'blocking')
+            summary: `Prepared ${proposal.impact.modelingChanges} modeling change${proposal.impact.modelingChanges === 1 ? '' : 's'} for review.`,
+            answer: blocked
                 ? 'I prepared a modeling proposal, but the blocking items must be resolved before it can be saved.'
-                : 'I prepared an evidence-bound modeling proposal. Review the exact source diff before saving it as a draft.',
+                : usedProvider
+                    ? 'I designed a modeling proposal from your dbt metadata. Every model and column was checked against the current snapshot. Review the exact source diff before saving it as a draft.'
+                    : 'No AI provider is configured, so these are evidence-only suggestions matched from dbt metadata rather than an AI proposal. Review the exact source diff before saving it as a draft.',
             status: 'needs_review',
             trustState: 'review_required',
             stopReason: 'human_review_required',
-            artifacts: [{ id: `${runId}:modeling-proposal`, kind: 'modeling_change_proposal', title: 'Modeling change proposal', trustState: 'review_required', ref: proposal.id, payload: proposal }],
+            artifacts: [{ id: `${runId}:modeling-proposal`, kind: 'modeling_change_proposal', title: usedProvider ? 'Modeling change proposal' : 'Evidence-only modeling suggestions', trustState: 'review_required', ref: proposal.id, payload: proposal }],
             evaluations: proposal.diagnostics.map((diagnostic) => ({ id: `${proposal.id}:${diagnostic.code}`, label: diagnostic.code, passed: diagnostic.severity !== 'blocking', severity: diagnostic.severity, message: diagnostic.message })),
             nextActions: [{ id: 'review-modeling-proposal', label: 'Review in Modeling', artifactKind: 'modeling_change_proposal' }],
         };
     };
     const skillAuthoringRunExecutor = async ({ runId, request }) => {
         const snapshot = projectSnapshot();
-        const operations = buildMetadataBoundSkillOperations(projectRoot, snapshot.manifest, request);
+        // SKILL-006: same contract as Modeling AI — a provider drafts the skill
+        // body and vocabulary; the template is the labelled fallback.
+        const provider = await createBlockStudioAssistProvider(projectRoot);
+        const operations = provider
+            ? await buildAiSkillOperations(projectRoot, snapshot.manifest, request, provider)
+                .catch(() => buildMetadataBoundSkillOperations(projectRoot, snapshot.manifest, request))
+            : buildMetadataBoundSkillOperations(projectRoot, snapshot.manifest, request);
         const proposal = previewContextAuthoring({
             origin: request.workspaceContext?.correction === true ? 'correction' : 'ai',
             operations,
-            expectedSnapshotId: typeof request.workspaceContext?.snapshotId === 'string' ? request.workspaceContext.snapshotId : snapshot.snapshotId,
+            // Same reasoning as the modeling executor above: base the draft on the
+            // snapshot it was built from; apply-time re-validation catches real drift.
+            expectedSnapshotId: snapshot.snapshotId,
             sourceRunId: runId,
             revision: Number(request.workspaceContext?.revision ?? 1),
         });
@@ -4173,6 +4383,48 @@ export async function startLocalServer(opts) {
             return [];
         }
     };
+    /**
+     * CTX-008: the project's authored relationships, as plain join facts for the
+     * relations a bounded repair can actually see.
+     *
+     * A repair prompt previously carried only the failure, the failed SQL, and a
+     * bare relation list, so a repair could silently replace a correct governed
+     * join with a shared-column guess. This is grounding only — it never widens
+     * the relation scope and never authorizes a join (`REL-002` still governs
+     * execution); trust is labelled so a draft edge reads as a draft.
+     */
+    const governedJoinFactsForRelations = (relations) => {
+        const modeling = (() => {
+            try {
+                return projectSnapshot().manifest.modeling;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        if (!modeling)
+            return [];
+        const manifest = projectSnapshot().manifest;
+        const normalize = (value) => value.toLowerCase().replace(/"/g, '').split('.').at(-1) ?? value.toLowerCase();
+        const visible = new Set(relations.map(normalize));
+        const relationFor = (entityKey) => {
+            const entity = modeling.entities[entityKey];
+            if (!entity)
+                return undefined;
+            const node = manifest.dbtProvenance?.nodes[entity.dbtUniqueId];
+            return node?.relation ?? node?.name;
+        };
+        return Object.values(modeling.relationships).flatMap((relationship) => {
+            const from = relationFor(relationship.from);
+            const to = relationFor(relationship.to);
+            if (!from || !to || !visible.has(normalize(from)) || !visible.has(normalize(to)))
+                return [];
+            const keys = relationship.keys.map((key) => `${from}.${key.from} = ${to}.${key.to}`).join(' AND ');
+            const trust = relationship.automaticJoinAllowed ? 'certified' : `${relationship.status} (review required)`;
+            const meaning = [relationship.verb, relationship.description].filter(Boolean).join(' — ');
+            return [`${keys} (${relationship.cardinality}, fanout ${relationship.fanout}, ${trust}${meaning ? `; ${meaning}` : ''})`];
+        }).slice(0, 12);
+    };
     const boundedRepairError = (message, status, warehouseFailure) => Object.assign(new Error(message), { status, ...(warehouseFailure ? { warehouseFailure } : {}) });
     /**
      * Shared one-attempt SQL repair for Ask and Notebook. It never creates a
@@ -4209,6 +4461,9 @@ export async function startLocalServer(opts) {
                 relation: table.relation,
                 columns: table.columns.slice(0, 40).map((column) => ({ name: column.name, type: column.type })),
             }));
+            // CTX-008: a repair that re-derives joins from column names can undo a
+            // join the original query got right. Give it the authored key pairs.
+            const governedJoins = governedJoinFactsForRelations(schemaContext.slice(0, 16).map((table) => table.relation));
             let raw;
             try {
                 raw = await provider.generate([
@@ -4222,6 +4477,7 @@ export async function startLocalServer(opts) {
                                 ? 'Preserve every positional parameter placeholder exactly; do not add, remove, or renumber placeholders.'
                                 : '',
                             'Use only relations and columns present in the supplied schema context.',
+                            'When governedJoins is present, join on those exact key pairs rather than inferring a join from column names.',
                             'Never emit internal DQL relation identities such as source::, model::, seed::, or snapshot::.',
                             'Do not add writes, DDL, multiple statements, or commentary outside the JSON fence.',
                         ].join(' '),
@@ -4238,6 +4494,7 @@ export async function startLocalServer(opts) {
                                 placeholder: `$${parameter.position}`,
                             })),
                             schema: boundedSchema,
+                            ...(governedJoins.length ? { governedJoins } : {}),
                         }),
                     },
                 ], { maxTokens: 1200, temperature: 0 });
@@ -4307,6 +4564,8 @@ export async function startLocalServer(opts) {
             relation: table.relation,
             columns: table.columns.slice(0, 40).map((column) => ({ name: column.name, type: column.type })),
         }));
+        // CTX-008: same as the SQL repair — keep authored joins out of the guesser.
+        const governedJoins = governedJoinFactsForRelations(schemaContext.slice(0, 16).map((table) => table.relation));
         let raw;
         try {
             raw = await provider.generate([
@@ -4319,6 +4578,7 @@ export async function startLocalServer(opts) {
                         'Preserve the block name, business fields, visualization, tests, requested grain, filters, output columns, and aggregation semantics.',
                         'Preserve every declared parameter and every ${parameter} interpolation exactly. Do not add or remove parameters.',
                         'Use only relations and columns present in the supplied schema context.',
+                        'When governedJoins is present, join on those exact key pairs rather than inferring a join from column names.',
                         'Never emit internal relation identities such as source::, model::, seed::, or snapshot::.',
                         'Return exactly one custom block. Never certify it, bind a saved block, add writes, DDL, or multiple SQL statements.',
                     ].join(' '),
@@ -4332,6 +4592,7 @@ export async function startLocalServer(opts) {
                         dql: input.source.slice(0, 40_000),
                         parameters: input.parameters ?? {},
                         schema: boundedSchema,
+                        ...(governedJoins.length ? { governedJoins } : {}),
                     }),
                 },
             ], { maxTokens: 2400, temperature: 0 });
@@ -5422,7 +5683,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
@@ -5444,6 +5708,7 @@ export async function startLocalServer(opts) {
             chartConfig: plan?.chartConfig ?? validation.chartConfig ?? null,
             invocation,
             tests: plan?.tests ?? [],
+            validation,
         };
     };
     const runBlockStudioTestSummary = async (source, targetConnection, executedPreview) => {
@@ -5544,12 +5809,13 @@ export async function startLocalServer(opts) {
         };
     };
     const certifyBlockStudioSource = async (source, blockPath, options = {}) => {
-        const validation = validateBlockStudioSource(source, semanticLayer);
+        let validation = validateBlockStudioSource(source, semanticLayer);
         let preview = null;
         let testResults = null;
         const blockers = [];
         try {
             preview = await runBlockStudioPreviewSource(source);
+            validation = preview.validation;
         }
         catch (error) {
             blockers.push(error instanceof Error ? error.message : String(error));
@@ -6621,10 +6887,13 @@ export async function startLocalServer(opts) {
                     const selectedCandidateIds = Array.isArray(body.selectedCandidateIds)
                         ? body.selectedCandidateIds.filter((value) => typeof value === 'string')
                         : session.candidates.filter((candidate) => candidate.dialect !== 'unsupported' && candidate.action !== 'open_existing').map((candidate) => candidate.id);
-                    const domain = typeof body.domain === 'string' ? body.domain.trim() : '';
-                    const areaId = typeof body.areaId === 'string' ? body.areaId.trim() : '';
-                    if (!domain || !areaId)
-                        throw Object.assign(new Error('Choose exactly one Domain and Model Area for imported models.'), { code: 'MODEL_SCOPE_REQUIRED' });
+                    // An unspecified scope is defaulted, not rejected: the proposal carries
+                    // the `upsert_domain`/`upsert_area` patches so the author reviews the
+                    // scope alongside the models it will hold.
+                    const domain = typeof body.domain === 'string' && body.domain.trim()
+                        ? body.domain.trim()
+                        : defaultAuthoringDomainId(snapshot.manifest);
+                    const areaId = typeof body.areaId === 'string' && body.areaId.trim() ? body.areaId.trim() : DEFAULT_MODEL_AREA_ID;
                     const planned = modelingImportOperations(session, selectedCandidateIds, domain, areaId, snapshot.manifest);
                     const proposal = previewContextAuthoring({
                         origin: 'yaml_import',
@@ -9008,20 +9277,23 @@ export async function startLocalServer(opts) {
                 }));
                 return;
             }
-            const appDashRun = path.match(/^\/api\/apps\/([^/]+)\/dashboards\/([^/]+)\/run$/);
+            const appDashRun = path.match(/^\/api\/(apps|app-builds)\/([^/]+)\/dashboards\/([^/]+)\/run$/);
             if (req.method === 'POST' && appDashRun) {
                 try {
-                    const appId = decodeURIComponent(appDashRun[1]);
-                    const dashboardId = decodeURIComponent(appDashRun[2]);
+                    const runSurface = appDashRun[1];
+                    const appId = decodeURIComponent(appDashRun[2]);
+                    const dashboardId = decodeURIComponent(appDashRun[3]);
                     const body = await readJSON(req).catch(() => ({}));
-                    const loaded = loadAppDashboard(projectRoot, appId, dashboardId);
+                    const loaded = runSurface === 'app-builds'
+                        ? loadAppBuildDraftDashboard(projectRoot, appId, dashboardId)
+                        : loadAppDashboard(projectRoot, appId, dashboardId);
                     if (!loaded) {
                         res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
-                        res.end(serializeJSON({ error: `Dashboard "${dashboardId}" not found in app "${appId}"` }));
+                        res.end(serializeJSON({ error: `Dashboard "${dashboardId}" not found in ${runSurface === 'app-builds' ? 'local App draft' : 'App'} "${appId}"` }));
                         return;
                     }
                     const activeApp = activePersonaAppId();
-                    if (activeApp && activeApp !== appId) {
+                    if (runSurface === 'apps' && activeApp && activeApp !== appId) {
                         res.writeHead(403, { 'Content-Type': 'application/json; charset=utf-8' });
                         res.end(serializeJSON({ error: `The active persona belongs to App "${activeApp}", not "${appId}".` }));
                         return;
@@ -9035,627 +9307,689 @@ 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;
-                                }
-                            }
-                            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 draftPath = join(loaded.appDir, item.draftAnalysis.ref);
-                                draftAppRelativePath = relative(loaded.appDir, 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 },
+                                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`,
                                     });
-                                    if (!repaired.ok) {
+                                    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) {
+                                    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: '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),
-                                            },
+                                            tileType: 'aiPin',
+                                            title: item.title ?? pin.title,
+                                            error: err instanceof Error ? err.message : String(err),
+                                            trustState: pinArtifact.trustState ?? 'review_required',
                                         });
                                         continue;
                                     }
-                                    result = repaired.result;
-                                    repair = repaired.repair;
-                                    repairedSql = repaired.repairedSql;
-                                    repairedDql = repaired.repairedDql;
+                                }
+                                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;
+                                    }
                                 }
                                 tiles.push({
                                     tileId: item.i,
                                     status: 'ok',
-                                    tileType: 'draftAnalysis',
-                                    title: item.title ?? item.i,
+                                    tileType: 'aiPin',
+                                    title: item.title ?? pin.title,
                                     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 } : {}),
+                                    chartConfig: mergeDashboardChartConfig(renderedPinChartConfig, item),
+                                    result: renderedPinResult,
+                                    aiPin: pin,
+                                    citation: {
+                                        kind: 'ai_pin',
+                                        name: pin.title,
+                                    },
                                     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',
+                                        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 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.',
+                                            '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;
                             }
-                            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.draftAnalysis) {
+                                let draftSource;
+                                let draftAppRelativePath;
+                                let draftParameters = {};
+                                let draftTargetConnection;
+                                let draftRepairPlan;
+                                try {
+                                    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(repaired.result.chartConfig, item),
-                                        result: repaired.result,
+                                        chartConfig: mergeDashboardChartConfig(result.chartConfig, item),
+                                        result,
                                         trustState: 'review_required',
-                                        citation: { kind: 'app_draft_analysis_repaired', name: item.title ?? item.i, path: draftAppRelativePath },
-                                        repair: repaired.repair,
+                                        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,
-                                            ...(draftAppRelativePath ? { sourcePath: draftAppRelativePath } : {}),
-                                            dql: (repaired.repairedDql ?? draftSource).slice(0, 40_000),
-                                            sql: repaired.repairedSql.slice(0, 40_000),
+                                            sourcePath: draftAppRelativePath,
+                                            dql: (repairedDql ?? draftSource).slice(0, 40_000),
+                                            ...(repairedSql ?? draftRepairPlan?.sql ? { sql: (repairedSql ?? draftRepairPlan.sql).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: [
+                                                '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),
                                         },
                                     });
-                                    continue;
-                                }
-                                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),
-                                        },
-                                    } : {}),
-                                });
-                            }
-                            continue;
-                        }
-                        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 = Object.entries(dashboardVariables)
-                                    .filter(([field, value]) => item.semantic.dimensions?.includes(field) && value !== undefined && value !== null && value !== '')
-                                    .map(([dimension, value]) => ({ dimension, operator: 'equals', values: Array.isArray(value) ? value.map(String) : [String(value)] }));
-                                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) {
+                                catch (err) {
                                     const repaired = await repairFailedAppTileExecution({
-                                        source: 'semantic_query',
-                                        question: item.title ?? item.semantic.id,
-                                        sourceSql: composed.sql,
-                                        error: executionError,
-                                        targetConnection,
+                                        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) {
+                                    if (repaired.ok && draftSource) {
                                         tiles.push({
                                             tileId: item.i,
-                                            status: 'error',
-                                            tileType: 'semantic',
-                                            title: item.title ?? item.semantic.id,
-                                            error: executionError instanceof Error ? executionError.message : String(executionError),
+                                            status: 'ok',
+                                            tileType: 'draftAnalysis',
+                                            title: item.title ?? item.i,
+                                            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: 'semantic_query',
-                                                name: item.title ?? item.semantic.id,
-                                                sql: composed.sql.slice(0, 40_000),
+                                                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),
                                                 trustState: 'review_required',
-                                                explanation: ['Automatic repair could not execute the governed semantic query safely.'],
+                                                explanation: ['A bounded DQL repair executed on the original data target. The saved App analysis was not changed.'],
                                                 executionTarget: executionTargetDescriptor(body),
                                             },
                                         });
                                         continue;
                                     }
-                                    normalizedResult = normalizeQueryResult(repaired.result);
-                                    repair = repaired.repair;
-                                    executedSql = repaired.repairedSql;
-                                }
-                                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),
+                                    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: [
-                                            `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),
-                                    },
-                                });
-                            }
-                            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: '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) {
-                                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,
-                                    },
-                                });
+                                        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;
                             }
-                            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',
-                                });
+                            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: '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),
+                                        },
+                                    });
+                                }
+                                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;
                             }
-                            blockFilterApplication = applyDashboardFiltersToBlockExecution({
-                                sql: semanticCompose?.sql ?? blockPlan.sql,
-                                sqlParams: blockPlan?.sqlParams ?? [],
-                                variables: { ...(blockPlan?.variables ?? {}), ...dashboardVariables },
-                                block,
-                                dashboard: loaded.dashboard,
-                            });
-                            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) {
+                            const block = resolveDashboardItemBlock(item, manifest);
+                            if (!block) {
                                 tiles.push({
                                     tileId: item.i,
-                                    status: 'unauthorized',
-                                    blockId: block.name,
-                                    error: err.message,
+                                    status: 'unresolved',
+                                    blockRef: item.block ? (isBlockIdRef(item.block) ? item.block.blockId : item.block.ref) : '(missing source)',
+                                    error: 'Block reference could not be resolved',
                                 });
+                                continue;
                             }
-                            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 ?? {}),
-                                    },
+                            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',
                                 });
-                                if (repaired.ok) {
+                                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: 'ok',
+                                        status: 'error',
                                         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: '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),
+                                        error: 'This App source changed after it was selected. Refresh the source binding and rerun preview.',
+                                    });
+                                    continue;
+                                }
+                                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,
                                         },
                                     });
                                     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: 'error',
-                                    tileType: 'block',
+                                    status: 'ok',
                                     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),
-                                        },
-                                    } : {}),
+                                    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: 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),
+                                    },
                                 });
                             }
+                            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: 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),
+                                            },
+                                        });
+                                        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),
+                                            },
+                                        } : {}),
+                                    });
+                                }
+                            }
                         }
-                    }
-                    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
+                    // HAVING, and picking such a column off the table would quietly change
+                    // the measure. The browser must never re-derive this.
+                    const runDialect = (() => {
+                        try {
+                            return requireActiveConnection().driver || 'duckdb';
+                        }
+                        catch {
+                            return 'duckdb';
+                        }
+                    })();
+                    const tilesWithFilters = tiles.map((tile) => {
+                        const executedSql = tile.artifact?.sql;
+                        const columns = tile.result?.columns ?? [];
+                        if (typeof executedSql !== 'string' || columns.length === 0)
+                            return tile;
+                        try {
+                            const dashboardItem = loaded.dashboard.layout.items.find((item) => item.i === tile.tileId);
+                            const block = dashboardItem ? resolveDashboardItemBlock(dashboardItem, manifest) : null;
+                            const declaredDimensions = block?.dimensions ?? [];
+                            const filterable = dashboardFilterableResultColumns(executedSql, columns, declaredDimensions, runDialect);
+                            return filterable.length > 0 ? { ...tile, filterableColumns: filterable } : tile;
+                        }
+                        catch {
+                            return tile; // Unparseable SQL simply offers no filter candidates.
+                        }
+                    });
+                    const filterOptions = collectDashboardFilterOptions(loaded.dashboard, tilesWithFilters);
                     const snapshot = projectSnapshot();
                     const filterFingerprint = createHash('sha256').update(JSON.stringify(dashboardVariables)).digest('hex');
                     const resultFingerprint = createHash('sha256').update(JSON.stringify(tiles.map((tile) => ({ tileId: tile.tileId, status: tile.status, result: tile.result })))).digest('hex');
@@ -9678,7 +10012,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,
@@ -9692,7 +10026,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);
@@ -9706,7 +10061,8 @@ export async function startLocalServer(opts) {
                         filterFingerprint,
                         resultFingerprint,
                         personaFingerprint,
-                        tiles,
+                        filterOptions,
+                        tiles: tilesWithFilters,
                         facts: storyResult.facts,
                         story: storyResult.story,
                     }));
@@ -9718,7 +10074,11 @@ export async function startLocalServer(opts) {
                 return;
             }
             // Apps, dashboards, persona — see apps-api.ts. Returns true if handled.
-            if (path.startsWith('/api/apps') || path.startsWith('/api/visualizations') || path === '/api/persona') {
+            if (path.startsWith('/api/apps')
+                || path.startsWith('/api/app-builds')
+                || path.startsWith('/api/app-recoveries')
+                || path.startsWith('/api/visualizations')
+                || path === '/api/persona') {
                 try {
                     const handled = await handleAppsApi({
                         req,
@@ -9741,6 +10101,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);
@@ -9764,6 +10135,18 @@ export async function startLocalServer(opts) {
                             }
                             return { ok: true, snapshotId: evidence.snapshotId, resultFingerprint: evidence.resultFingerprint };
                         },
+                        verifyAppBuildPreview: ({ runId, draftId, dashboardId, tileIds }) => {
+                            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);
+                            const failed = tileIds.filter((tileId) => !successful.has(tileId));
+                            if (failed.length > 0)
+                                return { ok: false, error: `These App components did not complete successfully: ${failed.join(', ')}` };
+                            return { ok: true, snapshotId: evidence.snapshotId, resultFingerprint: evidence.resultFingerprint };
+                        },
                         // Story narration for commit — LLM-backed with deterministic fallback.
                         narrate: narrateForAgentRun,
                     });
@@ -11316,13 +11699,12 @@ 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,
@@ -11330,8 +11712,22 @@ export async function startLocalServer(opts) {
                         owner: typeof suppliedMetadata.owner === 'string' ? suppliedMetadata.owner : parsed.owner,
                         tags: Array.isArray(suppliedMetadata.tags) ? suppliedMetadata.tags.map(String) : parsed.tags,
                         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}`,
@@ -11357,13 +11753,22 @@ export async function startLocalServer(opts) {
                         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.' });
@@ -11409,13 +11814,22 @@ export async function startLocalServer(opts) {
                             /* best-effort: learning capture must never block certification */
                         }
                         const refreshOperation = scheduleProjectRefresh('block-studio-certification');
+                        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 },
                         };
                     });
@@ -11433,6 +11847,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);
@@ -11450,6 +11890,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;
@@ -11469,10 +11911,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);
                         }
                     }
@@ -11512,7 +11958,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 },
                     }));
                 }
@@ -12278,15 +12724,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;
             }
@@ -15888,21 +16345,77 @@ function loadAppDashboard(projectRoot, appId, dashboardId) {
     }
     return null;
 }
-function resolveDashboardItemBlock(item, manifest) {
-    if (!item.block)
-        return null;
-    if (isBlockIdRef(item.block)) {
-        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;
-}
-function mergeDashboardChartConfig(base, item) {
-    const options = item.viz.options ?? {};
-    const baseChart = base?.chart;
-    return {
-        ...(base ?? {}),
-        ...options,
+/**
+ * Resolves an App Studio draft directly from local SQLite for read-only preview.
+ * The draft is never copied into the Git-owned `apps/` tree. This gives manual
+ * and AI authoring the same execution path and the same filter/story receipts
+ * as a published App while keeping publication explicit.
+ */
+function loadAppBuildDraftDashboard(projectRoot, draftId, dashboardId) {
+    const storage = new LocalAppStorage(defaultLocalAppsDbPath(projectRoot));
+    try {
+        const draft = storage.getAppBuildDraft(draftId);
+        if (!draft)
+            return null;
+        const dashboard = draft.pages.find((page) => page.id === dashboardId);
+        if (!dashboard)
+            return null;
+        const base = draft.baseApp ? findAppById(projectRoot, draft.baseApp.appId) : null;
+        const app = base?.app ?? {
+            version: 1,
+            id: draft.appId,
+            name: draft.name,
+            description: draft.frame.goal,
+            visibility: 'private',
+            publicationIntent: 'personal',
+            domain: dashboard.metadata.domain ?? 'general',
+            usesDomains: [],
+            requiredExports: [],
+            audience: draft.frame.audience || 'stakeholders',
+            lifecycle: 'draft',
+            owners: ['local-author'],
+            tags: ['app-studio', 'local-draft'],
+            members: [],
+            roles: [],
+            policies: [],
+            homepage: { type: 'dashboard', id: dashboard.id },
+        };
+        return {
+            app: { ...app, id: draft.appId, name: draft.name, visibility: 'private', lifecycle: 'draft' },
+            dashboard,
+            appDir: base?.appDir ?? join(projectRoot, '.dql', 'local', 'app-builds', draft.id),
+            draftArtifactsDir: join(projectRoot, '.dql', 'local', 'app-builds', draft.id),
+        };
+    }
+    finally {
+        storage.close();
+    }
+}
+function findAppById(projectRoot, appId) {
+    for (const path of findAppDocuments(projectRoot)) {
+        const { document: app } = loadAppDocument(path);
+        if (app?.id !== appId)
+            continue;
+        return { app, appDir: path.slice(0, -'/dql.app.json'.length) };
+    }
+    return null;
+}
+function resolveDashboardItemBlock(item, manifest) {
+    if (!item.block)
+        return null;
+    if (isBlockIdRef(item.block)) {
+        return manifest.blocks[item.block.blockId] ?? null;
+    }
+    const normalizedRef = normalize(item.block.ref).replaceAll('\\', '/');
+    return (manifest.blockDeclarations ?? Object.values(manifest.blocks))
+        .find((b) => normalize(b.filePath).replaceAll('\\', '/') === normalizedRef) ?? null;
+}
+function mergeDashboardChartConfig(base, item) {
+    const options = item.viz.options ?? {};
+    const baseChart = base?.chart;
+    return {
+        ...(base ?? {}),
+        ...options,
         chart: dashboardVizToChart(String(options.chart ?? baseChart ?? item.viz.type)),
     };
 }
@@ -16224,6 +16737,8 @@ export function parseDomainInput(raw, fallbackId) {
         sourcePath: typeof domain.sourcePath === 'string' ? domain.sourcePath : undefined,
     };
 }
+/** Bounded discovery: an import scan reads at most this many YAML files. */
+const MODELING_IMPORT_FILE_LIMIT = 100;
 function modelingImportDirectory(projectRoot) {
     return join(projectRoot, '.dql', 'local', 'modeling-imports');
 }
@@ -16260,6 +16775,7 @@ function createModelingImportSession(projectRoot, gitRoot, loopback, source) {
     if (mode !== 'current_project' && mode !== 'path' && mode !== 'upload' && mode !== 'paste')
         throw Object.assign(new Error('Choose current_project, path, upload, or paste.'), { code: 'INVALID_REQUEST' });
     const files = [];
+    const truncationWarnings = [];
     if (mode === 'paste' || mode === 'upload') {
         const content = typeof source.content === 'string' ? source.content : '';
         if (!content.trim() || Buffer.byteLength(content) > 1_000_000)
@@ -16278,11 +16794,17 @@ function createModelingImportSession(projectRoot, gitRoot, loopback, source) {
         const requested = realpathSync(requestedInput);
         if (requested !== allowedRoot && !requested.startsWith(`${allowedRoot}${sep}`))
             throw Object.assign(new Error('Import path must stay inside the current Git workspace.'), { code: 'PATH_ACCESS_FORBIDDEN' });
-        const paths = collectModelingYamlPaths(requested, 100);
+        const paths = collectModelingYamlPaths(requested, MODELING_IMPORT_FILE_LIMIT);
+        // Truncation used to be silent, which reads as "DQL did not find my file".
+        if (paths.length >= MODELING_IMPORT_FILE_LIMIT) {
+            truncationWarnings.push(`Only the first ${MODELING_IMPORT_FILE_LIMIT} YAML files in this location were scanned. Point the import at a narrower folder to see the rest.`);
+        }
         for (const path of paths) {
             const size = statSync(path).size;
-            if (size > 1_000_000)
+            if (size > 1_000_000) {
+                truncationWarnings.push(`Skipped ${relative(requested, path).replace(/\\/g, '/')}: larger than the 1 MB import limit.`);
                 continue;
+            }
             const resolvedPath = realpathSync(path);
             if (resolvedPath !== allowedRoot && !resolvedPath.startsWith(`${allowedRoot}${sep}`))
                 continue;
@@ -16301,6 +16823,7 @@ function createModelingImportSession(projectRoot, gitRoot, loopback, source) {
         updatedAt: now,
         source: { mode, label: mode === 'path' ? String(source.path ?? '') : mode === 'current_project' ? 'Current project' : files[0].name },
         candidates,
+        ...(truncationWarnings.length ? { warnings: truncationWarnings } : {}),
     };
     writeModelingImportSession(projectRoot, session);
     return session;
@@ -16368,10 +16891,12 @@ function modelingImportOperations(session, selectedIds, domain, areaId, manifest
         throw Object.assign(new Error('Select at least one supported YAML candidate.'), { code: 'MODELING_IMPORT_EMPTY' });
     const packageExists = Boolean(manifest.modeling?.packages?.[domain]);
     const area = Object.values(manifest.modeling?.areas ?? {}).find((item) => item.domain === domain && (item.localId === areaId || item.qualifiedId === areaId));
+    // A missing Domain/subject area is created by `ensureAuthoringScopeOperations`
+    // as part of this same proposal, so it is reported, not blocked.
     if (!packageExists)
-        diagnostics.push({ code: 'DOMAIN_NOT_FOUND', severity: 'blocking', message: `Domain not found: ${domain}` });
+        diagnostics.push({ code: 'DOMAIN_CREATED', severity: 'info', message: `Domain "${domain}" does not exist yet and will be created with these models.` });
     if (!area)
-        diagnostics.push({ code: 'MODEL_AREA_NOT_FOUND', severity: 'blocking', message: `Model Area not found in ${domain}: ${areaId}` });
+        diagnostics.push({ code: 'MODEL_AREA_CREATED', severity: 'info', message: `Subject area "${areaId}" does not exist yet in ${domain} and will be created with these models.` });
     const nodes = Object.values(manifest.dbtProvenance?.nodes ?? {});
     const resolveDbt = (reference, operationId) => {
         const cleaned = reference.replace(/^ref\(['"]|['"]\)$/g, '').replace(/^model\./, '');
@@ -16381,6 +16906,15 @@ function modelingImportOperations(session, selectedIds, domain, areaId, manifest
         return matches.length === 1 ? matches[0].uniqueId : undefined;
     };
     const used = new Set(Object.values(manifest.modeling?.entities ?? {}).filter((entity) => entity.domain === domain).map((entity) => entity.localId));
+    /**
+     * REL-004: dbt already declares its relationships. Every model this import
+     * binds is recorded here so the dbt `relationships` tests and MetricFlow
+     * `entities:` blocks covering those models become draft edges instead of
+     * leaving the author to redraw connections they already wrote down.
+     */
+    const boundEntityByDbtId = new Map();
+    const semanticPrimaryByName = new Map();
+    const semanticForeignRefs = [];
     const allocate = (value) => {
         const base = authoringSlug(value).replace(/-/g, '_') || 'model';
         let id = base;
@@ -16410,6 +16944,7 @@ function modelingImportOperations(session, selectedIds, domain, areaId, manifest
                     continue;
                 const sourceId = String(entity.id ?? nodes.find((node) => node.uniqueId === dbtModel)?.name ?? `model_${index + 1}`);
                 const id = allocate(sourceId);
+                boundEntityByDbtId.set(dbtModel, { id, operationId });
                 importedEntities.set(sourceId, { id, operationId });
                 importedEntities.set(String(entity.qualified_id ?? entity.qualifiedId ?? ''), { id, operationId });
                 importedEntities.set(dbtModel, { id, operationId });
@@ -16460,7 +16995,91 @@ function modelingImportOperations(session, selectedIds, domain, areaId, manifest
                     continue;
                 }
                 const id = existing?.localId ?? allocate(String(model.name ?? nodes.find((node) => node.uniqueId === dbtModel)?.name ?? `model_${index + 1}`));
-                operations.push({ id: operationId, kind: 'modeling_change', evidence: [candidate.path ?? candidate.name, dbtModel], change: { operation: 'upsert_entity', value: { id, domain, areaId: area?.localId ?? areaId, dbtModel, businessName: typeof model.name === 'string' ? titleCaseAuthoring(model.name) : undefined, businessContext: typeof model.description === 'string' ? model.description : undefined, status: 'draft', analyticalRole: 'unknown' } } });
+                boundEntityByDbtId.set(dbtModel, { id, operationId });
+                // MetricFlow states its own join graph in `entities:`; keep the primary
+                // key so the semantic branch can pair it with foreign references below.
+                const semanticEntities = contextArray(model.entities).map(contextRecord);
+                const primary = semanticEntities.find((entry) => entry.type === 'primary');
+                if (primary?.name)
+                    semanticPrimaryByName.set(String(primary.name), { dbtModel, column: String(primary.expr ?? primary.name) });
+                for (const entry of semanticEntities) {
+                    if (entry.type !== 'foreign' || !entry.name)
+                        continue;
+                    semanticForeignRefs.push({ name: String(entry.name), column: String(entry.expr ?? entry.name), dbtModel, operationId });
+                }
+                const aggTimeDimension = contextRecord(model.defaults).agg_time_dimension;
+                operations.push({ id: operationId, kind: 'modeling_change', evidence: [candidate.path ?? candidate.name, dbtModel], change: { operation: 'upsert_entity', value: { id, domain, areaId: area?.localId ?? areaId, dbtModel, businessName: typeof model.name === 'string' ? titleCaseAuthoring(model.name) : undefined, businessContext: typeof model.description === 'string' ? model.description : undefined, status: 'draft', analyticalRole: 'unknown', ...(typeof aggTimeDimension === 'string' ? { grain: aggTimeDimension } : {}), ...(primary?.name ? { keys: [String(primary.expr ?? primary.name)] } : {}) } } });
+            }
+        }
+    }
+    // REL-004: pair MetricFlow foreign references against the primary entity of
+    // the same name. This is dbt's own declared join graph, so it needs no
+    // guessing — but it is still only a draft candidate (REL-001).
+    for (const reference of semanticForeignRefs) {
+        const primary = semanticPrimaryByName.get(reference.name);
+        if (!primary || primary.dbtModel === reference.dbtModel)
+            continue;
+        const from = boundEntityByDbtId.get(reference.dbtModel);
+        const to = boundEntityByDbtId.get(primary.dbtModel);
+        if (!from || !to)
+            continue;
+        operations.push({
+            id: `semantic-entity:${from.id}:${to.id}:${reference.name}`,
+            kind: 'modeling_change',
+            dependsOn: [...new Set([from.operationId, to.operationId])],
+            evidence: [`MetricFlow entity "${reference.name}" declared foreign in ${reference.dbtModel} and primary in ${primary.dbtModel}`],
+            change: {
+                operation: 'upsert_relationship',
+                value: {
+                    id: `${from.id}_to_${to.id}`, domain, areaId: area?.localId ?? areaId,
+                    from: from.id, to: to.id,
+                    keys: [{ from: reference.column, to: primary.column }],
+                    cardinality: 'many_to_one', fanout: 'unknown', status: 'draft',
+                    verb: reference.name,
+                    rationale: 'Declared by the MetricFlow semantic entity graph. Validate against the warehouse before certifying.',
+                },
+            },
+        });
+    }
+    // REL-004: dbt `relationships` tests state an exact key pair and are already
+    // enforced by `dbt test`, which makes them the strongest available candidate.
+    // They remain drafts: a dbt test is evidence, never join authorization.
+    const manifestPath = manifest.dbtProvenance?.manifestPath;
+    if (manifestPath && boundEntityByDbtId.size > 1) {
+        let rawManifest;
+        try {
+            rawManifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        }
+        catch {
+            rawManifest = undefined;
+        }
+        if (rawManifest) {
+            for (const edge of collectDbtRelationshipTests(rawManifest, new Set(boundEntityByDbtId.keys()))) {
+                if (edge.fromColumn === 'unknown' || edge.toColumn === 'unknown')
+                    continue;
+                const from = boundEntityByDbtId.get(edge.fromDbtUniqueId);
+                const to = boundEntityByDbtId.get(edge.toDbtUniqueId);
+                if (!from || !to || from.id === to.id)
+                    continue;
+                const id = `${from.id}_to_${to.id}`;
+                if (operations.some((operation) => operation.kind === 'modeling_change' && operation.change.operation === 'upsert_relationship' && operation.change.value.id === id))
+                    continue;
+                operations.push({
+                    id: `dbt-test:${edge.testUniqueId}`,
+                    kind: 'modeling_change',
+                    dependsOn: [...new Set([from.operationId, to.operationId])],
+                    evidence: [edge.testUniqueId, ...(edge.sourcePath ? [edge.sourcePath] : [])],
+                    change: {
+                        operation: 'upsert_relationship',
+                        value: {
+                            id, domain, areaId: area?.localId ?? areaId,
+                            from: from.id, to: to.id,
+                            keys: [{ from: edge.fromColumn, to: edge.toColumn }],
+                            cardinality: 'many_to_one', fanout: 'unknown', status: 'draft',
+                            rationale: `Declared by the dbt relationships test ${edge.testUniqueId}. Validate against the warehouse before certifying.`,
+                        },
+                    },
+                });
             }
         }
     }
@@ -16515,7 +17134,7 @@ function parseContextAuthoringOperations(value) {
         const evidence = Array.isArray(operation.evidence) ? operation.evidence.filter((item) => typeof item === 'string').slice(0, 32) : undefined;
         if (operation.kind === 'modeling_change') {
             const change = operation.change;
-            const allowed = new Set(['upsert_domain', 'upsert_area', 'upsert_entity', 'upsert_relationship', 'upsert_contract', 'upsert_export', 'upsert_import', 'remove_entity', 'remove_relationship', 'remove_area']);
+            const allowed = new Set(['upsert_domain', 'upsert_area', 'upsert_entity', 'upsert_relationship', 'upsert_contract', 'upsert_export', 'upsert_import', 'remove_entity', 'remove_relationship', 'remove_area', 'remove_contract', 'remove_export', 'remove_import']);
             if (!change || typeof change !== 'object' || !allowed.has(change.operation) || !('value' in change) || !change.value || typeof change.value !== 'object')
                 throw Object.assign(new Error(`Modeling operation ${id} is invalid.`), { code: 'INVALID_REQUEST' });
             return { id, kind: 'modeling_change', change, dependsOn, evidence };
@@ -16553,7 +17172,225 @@ function resolveContextPatchPath(projectRoot, gitRoot, relativePath) {
     }
     return absolute;
 }
-function buildMetadataBoundModelingOperations(projectRoot, manifest, request) {
+/**
+ * Modeling AI: propose modeling changes from repository metadata.
+ *
+ * `AGT-024` — the model receives manifest identifiers, columns, lineage, tests,
+ * current modeling, and source locations, and never query rows. It proposes;
+ * this function then validates every identifier against the live snapshot and
+ * drops anything invented, so a hallucinated model or column cannot enter a
+ * proposal. `previewContextAuthoring` independently forces `status: 'draft'`,
+ * strips certification and validation, and blocks deletes and cross-domain
+ * relationships, so nothing here can certify or authorize a join.
+ */
+async function buildAiModelingOperations(projectRoot, manifest, request, provider) {
+    const modeling = manifest.modeling;
+    if (!modeling || !manifest.dbtProvenance)
+        throw new Error('Modeling AI requires a compiled dbt-first project snapshot.');
+    const context = request.workspaceContext ?? {};
+    const requestedDomain = typeof context.domain === 'string'
+        ? context.domain
+        : request.selectedObject?.kind === 'domain' ? request.selectedObject.id : undefined;
+    const domain = requestedDomain ?? Object.keys(modeling.packages)[0] ?? defaultAuthoringDomainId(manifest);
+    const requestedArea = typeof context.modelAreaId === 'string' ? context.modelAreaId : typeof context.areaId === 'string' ? context.areaId : undefined;
+    const area = Object.values(modeling.areas).find((candidate) => candidate.domain === domain
+        && (!requestedArea || candidate.qualifiedId === requestedArea || candidate.localId === requestedArea));
+    const areaId = area?.localId ?? modelAreaLocalId(requestedArea) ?? DEFAULT_MODEL_AREA_ID;
+    const bound = new Set(Object.values(modeling.entities).map((entity) => entity.dbtUniqueId));
+    const manifestPath = resolveDbtManifestPath(projectRoot);
+    const describe = (uniqueId) => {
+        const detail = manifestPath ? loadDbtNodeAuthoringDetail(manifestPath, uniqueId) : undefined;
+        return {
+            dbtUniqueId: uniqueId,
+            name: manifest.dbtProvenance.nodes[uniqueId]?.name,
+            relation: manifest.dbtProvenance.nodes[uniqueId]?.relation,
+            description: detail?.description,
+            columns: (detail?.columns ?? []).slice(0, 60).map((column) => ({ name: column.name, type: column.type, description: column.description })),
+            tests: (detail?.tests ?? []).slice(0, 40),
+        };
+    };
+    // Bound as candidates so a large project still fits a prompt.
+    const unbound = Object.values(manifest.dbtProvenance.nodes).filter((node) => !bound.has(node.uniqueId));
+    const tokens = authoringTokens(request.question);
+    const ranked = [
+        ...unbound.filter((node) => tokens.some((token) => `${node.name} ${node.uniqueId} ${node.sourcePath ?? ''}`.toLowerCase().includes(token))),
+        ...unbound,
+    ].filter((node, index, values) => values.findIndex((other) => other.uniqueId === node.uniqueId) === index).slice(0, 24);
+    const payload = {
+        request: request.question.trim(),
+        targetDomain: domain,
+        targetAreaId: areaId,
+        currentModels: Object.values(modeling.entities).filter((entity) => entity.domain === domain).map((entity) => ({
+            id: entity.localId, dbtUniqueId: entity.dbtUniqueId, businessName: entity.businessName,
+            businessContext: entity.businessContext, grain: entity.grain, keys: entity.keys, analyticalRole: entity.analyticalRole,
+        })),
+        currentRelationships: Object.values(modeling.relationships).filter((relationship) => relationship.ownerDomain === domain).map((relationship) => ({
+            id: relationship.localId, from: modeling.entities[relationship.from]?.localId, to: modeling.entities[relationship.to]?.localId,
+            keys: relationship.keys, cardinality: relationship.cardinality, fanout: relationship.fanout, status: relationship.status,
+        })),
+        availableDbtModels: ranked.map((node) => describe(node.uniqueId)),
+        focusedModel: request.selectedObject?.kind === 'model'
+            ? Object.values(modeling.entities).find((entity) => entity.qualifiedId === request.selectedObject.id)
+            : undefined,
+    };
+    let raw;
+    try {
+        raw = await provider.generate([
+            {
+                role: 'system',
+                content: [
+                    'You design analytical data models. Propose modeling changes for review; you are never applying them.',
+                    'Return exactly one JSON object in a ```json fence: {"operations":[...]}. No prose outside the fence.',
+                    'Each operation is {"kind":"upsert_entity","id":"<snake_case>","dbtModel":"<exact dbt unique id>","businessName":"...","businessContext":"...","grain":"...","keys":["..."],"analyticalRole":"event|dimension|snapshot|bridge|unknown"}',
+                    'or {"kind":"upsert_relationship","id":"<snake_case>","from":"<entity id>","to":"<entity id>","keys":[{"from":"<column>","to":"<column>"}],"cardinality":"one_to_one|one_to_many|many_to_one|many_to_many|unknown","fanout":"safe|dedupe_required|attribution_required|forbidden|unknown","verb":"...","description":"...","rationale":"..."}.',
+                    'Use ONLY dbt unique ids and column names present in the supplied metadata. Never invent an identifier.',
+                    'businessContext states what one row means in business terms. Never restate the request back as business context.',
+                    'Set cardinality and fanout from the evidence; use "unknown" when the metadata does not establish them. Never claim a relationship is certified or validated.',
+                    'Do not propose deletions, cross-domain relationships, or changes to dbt-owned SQL, columns, tests, or descriptions.',
+                ].join(' '),
+            },
+            { role: 'user', content: JSON.stringify(payload) },
+        ], { maxTokens: 3000, temperature: 0 });
+    }
+    catch (error) {
+        throw new Error(`The AI provider could not complete this modeling request: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const parsed = parseAiModelingOperations(raw);
+    if (parsed.length === 0)
+        throw new Error('Modeling AI did not return any usable modeling changes. Try naming the models or the relationship you want.');
+    // Validate every identifier against the live snapshot. An operation that
+    // references something the project does not have is dropped, not repaired.
+    const knownDbtIds = new Set(Object.keys(manifest.dbtProvenance.nodes));
+    const columnsFor = new Map();
+    const proposedEntityIds = new Set(Object.values(modeling.entities).filter((entity) => entity.domain === domain).map((entity) => entity.localId));
+    const operations = [];
+    for (const candidate of parsed) {
+        if (candidate.kind === 'upsert_entity') {
+            if (!candidate.dbtModel || !knownDbtIds.has(candidate.dbtModel))
+                continue;
+            const id = authoringSlug(candidate.id || candidate.dbtModel.split('.').at(-1) || 'model').replace(/-/g, '_');
+            if (!id)
+                continue;
+            proposedEntityIds.add(id);
+            const detail = manifestPath ? loadDbtNodeAuthoringDetail(manifestPath, candidate.dbtModel) : undefined;
+            const columns = new Set((detail?.columns ?? []).map((column) => column.name.toLowerCase()));
+            columnsFor.set(id, columns);
+            operations.push({
+                id: `entity:${domain}:${id}`,
+                kind: 'modeling_change',
+                evidence: [candidate.dbtModel, ...(detail?.sourcePath ? [detail.sourcePath] : [])],
+                change: {
+                    operation: 'upsert_entity',
+                    value: {
+                        id, domain, areaId, dbtModel: candidate.dbtModel,
+                        businessName: candidate.businessName?.trim() || titleCaseAuthoring(id),
+                        businessContext: candidate.businessContext?.trim() || undefined,
+                        grain: candidate.grain && columns.has(candidate.grain.toLowerCase()) ? candidate.grain : undefined,
+                        keys: (candidate.keys ?? []).filter((key) => columns.has(key.toLowerCase())),
+                        analyticalRole: parseImportedAnalyticalRole(candidate.analyticalRole) ?? 'unknown',
+                        status: 'draft',
+                    },
+                },
+            });
+            continue;
+        }
+        const from = authoringSlug(candidate.from ?? '').replace(/-/g, '_');
+        const to = authoringSlug(candidate.to ?? '').replace(/-/g, '_');
+        if (!proposedEntityIds.has(from) || !proposedEntityIds.has(to) || from === to)
+            continue;
+        const knownColumns = (entityId) => {
+            const cached = columnsFor.get(entityId);
+            if (cached)
+                return cached;
+            const entity = Object.values(modeling.entities).find((item) => item.domain === domain && item.localId === entityId);
+            const detail = entity && manifestPath ? loadDbtNodeAuthoringDetail(manifestPath, entity.dbtUniqueId) : undefined;
+            const columns = new Set((detail?.columns ?? []).map((column) => column.name.toLowerCase()));
+            columnsFor.set(entityId, columns);
+            return columns;
+        };
+        const fromColumns = knownColumns(from);
+        const toColumns = knownColumns(to);
+        const keys = (candidate.keys ?? []).filter((key) => key?.from && key?.to && fromColumns.has(key.from.toLowerCase()) && toColumns.has(key.to.toLowerCase()));
+        if (keys.length === 0)
+            continue;
+        const id = authoringSlug(candidate.id || `${from}_to_${to}`).replace(/-/g, '_');
+        operations.push({
+            id: `relationship:${domain}:${id}`,
+            kind: 'modeling_change',
+            dependsOn: [`entity:${domain}:${from}`, `entity:${domain}:${to}`].filter((dependency) => operations.some((operation) => operation.id === dependency)),
+            evidence: ['Modeling AI proposal from dbt metadata; requires warehouse validation before certification'],
+            change: {
+                operation: 'upsert_relationship',
+                value: {
+                    id, domain, areaId, from, to, keys,
+                    cardinality: parseImportedCardinality(candidate.cardinality),
+                    fanout: parseImportedFanout(candidate.fanout),
+                    status: 'draft',
+                    verb: candidate.verb?.trim() || undefined,
+                    description: candidate.description?.trim() || undefined,
+                    rationale: candidate.rationale?.trim() || undefined,
+                },
+            },
+        });
+    }
+    if (operations.length === 0)
+        throw new Error('Modeling AI referenced models or columns that are not in the current dbt snapshot, so nothing was proposed.');
+    return operations;
+}
+/** Tolerant JSON extraction; a malformed provider reply yields no operations. */
+export function parseAiModelingOperations(raw) {
+    const fenced = raw.match(/```json\s*([\s\S]*?)```/i)?.[1] ?? raw.match(/```\s*([\s\S]*?)```/)?.[1] ?? raw;
+    let parsed;
+    try {
+        parsed = JSON.parse(fenced.trim());
+    }
+    catch {
+        return [];
+    }
+    const text = (value) => (typeof value === 'string' ? value : undefined);
+    return contextArray(contextRecord(parsed).operations).flatMap((value) => {
+        const record = contextRecord(value);
+        if (record.kind === 'upsert_entity') {
+            return [{
+                    kind: 'upsert_entity',
+                    id: text(record.id),
+                    dbtModel: text(record.dbtModel),
+                    businessName: text(record.businessName),
+                    businessContext: text(record.businessContext),
+                    grain: text(record.grain),
+                    analyticalRole: record.analyticalRole,
+                    keys: contextStrings(record.keys),
+                }];
+        }
+        if (record.kind === 'upsert_relationship') {
+            return [{
+                    kind: 'upsert_relationship',
+                    id: text(record.id),
+                    from: text(record.from),
+                    to: text(record.to),
+                    verb: text(record.verb),
+                    description: text(record.description),
+                    rationale: text(record.rationale),
+                    cardinality: record.cardinality,
+                    fanout: record.fanout,
+                    keys: contextArray(record.keys).flatMap((entry) => {
+                        const key = contextRecord(entry);
+                        return typeof key.from === 'string' && typeof key.to === 'string' ? [{ from: key.from, to: key.to }] : [];
+                    }),
+                }];
+        }
+        return [];
+    });
+}
+/**
+ * Evidence-only modeling suggestions: deterministic, no provider required.
+ *
+ * This is the `AGT-024` provider-unavailable fallback, not "Modeling AI". It
+ * matches dbt model names against the request and pairs shared `*_id` columns.
+ * Callers must label its output honestly so a user is never told a template
+ * expansion was an AI proposal.
+ */
+function buildDeterministicModelingOperations(projectRoot, manifest, request) {
     const modeling = manifest.modeling;
     if (!modeling || !manifest.dbtProvenance)
         throw new Error('Modeling AI requires a compiled dbt-first project snapshot.');
@@ -16589,7 +17426,7 @@ function buildMetadataBoundModelingOperations(projectRoot, manifest, request) {
                     value: {
                         id: selectedRelationship.localId,
                         domain: selectedRelationship.ownerDomain ?? domain,
-                        areaId: selectedRelationship.areaId?.split('::area::').at(-1),
+                        areaId: modelAreaLocalId(selectedRelationship.areaId),
                         from: modeling.entities[selectedRelationship.from]?.localId ?? selectedRelationship.from,
                         to: modeling.entities[selectedRelationship.to]?.localId ?? selectedRelationship.to,
                         keys: selectedRelationship.keys,
@@ -16617,33 +17454,15 @@ function buildMetadataBoundModelingOperations(projectRoot, manifest, request) {
         ? Object.values(modeling.entities).find((item) => item.qualifiedId === selectedIdentity || item.id === selectedIdentity || item.localId === selectedIdentity)
         : undefined;
     if (selectedEntity) {
-        return [{
-                id: `entity:${selectedEntity.qualifiedId}`,
-                kind: 'modeling_change',
-                evidence: [selectedEntity.sourcePath, selectedEntity.dbtUniqueId],
-                change: {
-                    operation: 'upsert_entity',
-                    value: {
-                        id: selectedEntity.localId,
-                        domain: selectedEntity.domain,
-                        areaId: selectedEntity.areaId?.split('::area::').at(-1),
-                        dbtModel: selectedEntity.dbtUniqueId,
-                        businessName: selectedEntity.businessName,
-                        businessContext: request.question.trim(),
-                        conceptRefs: selectedEntity.conceptRefs,
-                        analyticalRole: selectedEntity.analyticalRole,
-                        status: 'draft',
-                        owner: selectedEntity.owner,
-                        grain: selectedEntity.grain,
-                        keys: selectedEntity.keys,
-                    },
-                },
-            }];
+        // Without a provider there is nothing evidence-backed to propose here.
+        // Copying the raw request into `businessContext` would present the user's
+        // own prompt back to them as authored business meaning.
+        throw new Error('Writing business context needs an AI provider. Configure one in Settings, or edit this model directly in Modeling.');
     }
     const requestedArea = typeof context.modelAreaId === 'string' ? context.modelAreaId : typeof context.areaId === 'string' ? context.areaId : undefined;
     const existingArea = Object.values(modeling.areas).find((area) => area.domain === domain
         && (!requestedArea || area.qualifiedId === requestedArea || area.localId === requestedArea));
-    const areaId = existingArea?.localId ?? requestedArea?.split('::area::').at(-1) ?? `${authoringSlug(request.question).slice(0, 36) || 'metadata'}_models`;
+    const areaId = existingArea?.localId ?? modelAreaLocalId(requestedArea) ?? `${authoringSlug(request.question).slice(0, 36) || 'metadata'}_models`;
     const operations = [];
     if (!existingArea) {
         operations.push({
@@ -16701,6 +17520,81 @@ function buildMetadataBoundModelingOperations(projectRoot, manifest, request) {
     }
     return operations;
 }
+/**
+ * Skills AI: draft a domain skill's purpose, guardrails, and vocabulary.
+ *
+ * `SKILL-006` — the model sees qualified modeling/metric references, the
+ * current skill, and the Domain/Area scope. It writes prose and vocabulary
+ * only; every governed reference is taken from the deterministic base built
+ * below, so it cannot invent a metric, block, or model. `previewContextAuthoring`
+ * independently forces `status: 'draft'`, so a drafted skill never guides an
+ * agent until a human activates it.
+ */
+async function buildAiSkillOperations(projectRoot, manifest, request, provider) {
+    const base = buildMetadataBoundSkillOperations(projectRoot, manifest, request);
+    const operation = base[0];
+    if (!operation || operation.kind !== 'skill_change')
+        return base;
+    const raw = await provider.generate([
+        {
+            role: 'system',
+            content: [
+                'You write governed analytics guidance for one business domain.',
+                'Return exactly one JSON object in a ```json fence: {"description":"...","body":"...","triggers":["..."],"clarifyWhen":["..."],"vocabulary":{"term":"meaning"}}. No prose outside the fence.',
+                'body is markdown with a "## Purpose" section, a "## Guardrails" section, and a "## Clarify" section.',
+                'Write guidance an analyst would follow. Never restate the request back as the guidance.',
+                'Never name a metric, block, model, or relationship that is not in the supplied governed references.',
+                'Do not grant tools, authorize joins or data access, activate the skill, or write executable code.',
+            ].join(' '),
+        },
+        {
+            role: 'user',
+            content: JSON.stringify({
+                request: request.question.trim(),
+                domain: operation.value.domain,
+                modelAreaRefs: operation.value.modelAreaRefs,
+                currentSkill: { id: operation.value.id, description: operation.value.description, body: operation.value.body },
+                governedReferences: {
+                    metrics: operation.value.preferredMetrics,
+                    blocks: operation.value.preferredBlocks,
+                    modelingRefs: operation.value.sourceRefs,
+                },
+            }),
+        },
+    ], { maxTokens: 2000, temperature: 0.2 });
+    const fenced = raw.match(/```json\s*([\s\S]*?)```/i)?.[1] ?? raw.match(/```\s*([\s\S]*?)```/)?.[1] ?? raw;
+    let parsed;
+    try {
+        parsed = contextRecord(JSON.parse(fenced.trim()));
+    }
+    catch {
+        return base;
+    }
+    const body = typeof parsed.body === 'string' ? parsed.body.trim() : '';
+    if (!body)
+        return base;
+    const vocabulary = contextRecord(parsed.vocabulary);
+    return [{
+            ...operation,
+            evidence: [...(operation.evidence ?? []), 'drafted by Skills AI from governed references only'],
+            value: {
+                ...operation.value,
+                description: typeof parsed.description === 'string' && parsed.description.trim() ? parsed.description.trim() : operation.value.description,
+                body,
+                triggers: contextStrings(parsed.triggers).slice(0, 12).length ? contextStrings(parsed.triggers).slice(0, 12) : operation.value.triggers,
+                clarifyWhen: contextStrings(parsed.clarifyWhen).slice(0, 8).length ? contextStrings(parsed.clarifyWhen).slice(0, 8) : operation.value.clarifyWhen,
+                vocabulary: Object.fromEntries(Object.entries(vocabulary)
+                    .filter(([, value]) => typeof value === 'string')
+                    .slice(0, 24)),
+                // Governed references always come from the deterministic base; the model
+                // never gets to add one.
+                preferredMetrics: operation.value.preferredMetrics,
+                preferredBlocks: operation.value.preferredBlocks,
+                sourceRefs: operation.value.sourceRefs,
+                status: 'draft',
+            },
+        }];
+}
 function buildMetadataBoundSkillOperations(projectRoot, manifest, request) {
     const context = request.workspaceContext ?? {};
     const selectedIdentity = request.selectedObject?.kind === 'skill' ? request.selectedObject.id : undefined;
@@ -16761,6 +17655,18 @@ function buildMetadataBoundSkillOperations(projectRoot, manifest, request) {
             value,
         }];
 }
+/**
+ * The Domain an author lands in when none is selected: the single existing
+ * Domain if there is exactly one, otherwise a new one named after the dbt
+ * project. Callers keep full control — this is only the prefilled default.
+ */
+function defaultAuthoringDomainId(manifest) {
+    const packages = Object.keys(manifest.modeling?.packages ?? {});
+    if (packages.length === 1)
+        return packages[0];
+    const projectName = manifest.dbtProvenance?.projectName;
+    return projectName ? authoringSlug(projectName).replace(/-/g, '_') || 'analytics' : 'analytics';
+}
 function authoringTokens(value) {
     const stop = new Set(['the', 'and', 'for', 'with', 'from', 'this', 'that', 'build', 'create', 'model', 'models', 'skill', 'please', 'into', 'about']);
     return [...new Set(value.toLowerCase().split(/[^a-z0-9_]+/).filter((token) => token.length > 2 && !stop.has(token)))];
@@ -18184,6 +19090,132 @@ export function dashboardRuntimeVariables(dashboard, overrides = {}) {
     }
     return { ...variables, ...overrides };
 }
+/** Resolve semantic filters only through the component's explicit mapping. */
+export function dashboardSemanticFiltersForTile(dashboard, item, dashboardValues) {
+    if (!item.semantic)
+        return [];
+    return (dashboard.filters ?? []).flatMap((filter) => {
+        if (filter.scope?.tileIds && !filter.scope.tileIds.includes(item.i))
+            return [];
+        const binding = item.filterBindings?.find((candidate) => candidate.filter === filter.id
+            && candidate.capability !== 'unsupported'
+            && !candidate.unsupportedReason);
+        const dimension = binding?.binding;
+        const value = dashboardValues[filter.id];
+        if (!dimension || !item.semantic?.dimensions?.includes(dimension) || isEmptyDashboardFilterValue(value))
+            return [];
+        const values = Array.isArray(value) ? value.map(String) : [String(value)];
+        return [{ dimension, operator: values.length > 1 ? 'in' : 'equals', values }];
+    });
+}
+/**
+ * Return bounded, run-scoped filter choices only from columns the server has
+ * already proven safe for predicate filtering. These sampled labels are sent
+ * to the browser for a searchable control and are never written to `.dqld`.
+ */
+export function collectDashboardFilterOptions(dashboard, tiles, defaultLimit = 100) {
+    const items = new Map(dashboard.layout.items.map((item) => [item.i, item]));
+    const optionSets = [];
+    for (const filter of dashboard.filters ?? []) {
+        if (filter.type === 'boolean' || filter.type === 'relative_date' || filter.type === 'number_range')
+            continue;
+        const dateControl = filter.type === 'daterange' || filter.type === 'date';
+        const limit = Math.max(1, Math.min(100, filter.optionSource?.limit ?? defaultLimit));
+        const values = new Set();
+        const sourceTileIds = [];
+        let truncated = false;
+        for (const tile of tiles) {
+            const result = dashboardFilterOptionResult(tile.result);
+            if (tile.status !== 'ok' || !result?.rows.length)
+                continue;
+            const item = items.get(tile.tileId);
+            const binding = item?.filterBindings?.find((candidate) => candidate.filter === filter.id && candidate.capability !== 'unsupported');
+            if (!binding)
+                continue;
+            const requestedColumn = dashboardOutputColumn(binding?.binding ?? filter.field?.name ?? filter.bindsTo ?? filter.id);
+            if (!requestedColumn)
+                continue;
+            const safeColumn = tile.filterableColumns?.find((candidate) => normalizeDashboardOptionColumn(candidate.column) === normalizeDashboardOptionColumn(requestedColumn));
+            if (!safeColumn)
+                continue;
+            const resultColumn = result.columns.find((column) => normalizeDashboardOptionColumn(column) === normalizeDashboardOptionColumn(safeColumn.column));
+            if (!resultColumn)
+                continue;
+            sourceTileIds.push(tile.tileId);
+            for (const row of result.rows) {
+                const value = dashboardFilterOptionValue(row[resultColumn]);
+                if (value !== null)
+                    values.add(value);
+            }
+            if (result.truncated || (result.rowCount ?? result.rows.length) > result.rows.length)
+                truncated = true;
+        }
+        if (values.size === 0) {
+            if (dateControl) {
+                optionSets.push({
+                    filterId: filter.id,
+                    values: [],
+                    truncated,
+                    sourceTileIds: Array.from(new Set(sourceTileIds)),
+                    valueCount: 0,
+                });
+            }
+            continue;
+        }
+        const sorted = Array.from(values).sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }));
+        const dateValues = dateControl
+            ? sorted
+                .map((value) => ({ value, timestamp: Date.parse(value) }))
+                .filter((item) => Number.isFinite(item.timestamp))
+                .sort((left, right) => left.timestamp - right.timestamp)
+            : [];
+        optionSets.push({
+            filterId: filter.id,
+            values: dateControl ? [] : sorted.slice(0, limit),
+            truncated: dateControl ? truncated : truncated || sorted.length > limit,
+            sourceTileIds: Array.from(new Set(sourceTileIds)),
+            ...(dateControl ? {
+                valueCount: dateValues.length,
+                ...(dateValues.length ? {
+                    dateRange: {
+                        min: new Date(dateValues[0].timestamp).toISOString().slice(0, 10),
+                        max: new Date(dateValues[dateValues.length - 1].timestamp).toISOString().slice(0, 10),
+                    },
+                } : {}),
+            } : {}),
+        });
+    }
+    return optionSets;
+}
+function dashboardFilterOptionResult(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    if (!Array.isArray(record.columns) || !record.columns.every((column) => typeof column === 'string'))
+        return null;
+    if (!Array.isArray(record.rows) || !record.rows.every((row) => Boolean(row) && typeof row === 'object' && !Array.isArray(row)))
+        return null;
+    return {
+        columns: record.columns,
+        rows: record.rows,
+        ...(typeof record.rowCount === 'number' ? { rowCount: record.rowCount } : {}),
+        ...(typeof record.truncated === 'boolean' ? { truncated: record.truncated } : {}),
+    };
+}
+function normalizeDashboardOptionColumn(value) {
+    return value.replace(/[`"[\]]/g, '').trim().split('.').filter(Boolean).at(-1)?.toLowerCase() ?? '';
+}
+function dashboardFilterOptionValue(value) {
+    if (typeof value === 'string')
+        return value.trim() ? value : null;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    if (typeof value === 'boolean')
+        return String(value);
+    if (value instanceof Date && Number.isFinite(value.getTime()))
+        return value.toISOString();
+    return null;
+}
 /**
  * Resolve only declared tile parameter bindings.  Dashboard filters remain
  * values; they never become SQL identifiers or an implicit name-based binding.
@@ -18224,6 +19256,10 @@ export function applyDashboardFiltersToBlockExecution(input) {
     const clauses = [];
     let nextPosition = sqlParams.reduce((max, param) => Math.max(max, param.position), 0);
     for (const filter of input.dashboard.filters ?? []) {
+        if (filter.scope?.tileIds && input.tileId && !filter.scope.tileIds.includes(input.tileId)) {
+            skippedFilters.push({ filter: filter.id, reason: 'component is outside this filter scope' });
+            continue;
+        }
         const value = dashboardFilterValue(filter, variables);
         if (isEmptyDashboardFilterValue(value)) {
             skippedFilters.push({ filter: filter.id, reason: 'no value supplied' });
@@ -18238,7 +19274,7 @@ export function applyDashboardFiltersToBlockExecution(input) {
             });
             continue;
         }
-        const binding = resolveDashboardFilterBinding(filter, input.block);
+        const binding = resolveDashboardFilterBinding(filter, input.block, input.tileFilterBindings);
         if (!binding) {
             skippedFilters.push({ filter: filter.id, reason: `block "${input.block.name}" does not declare a compatible filter binding` });
             continue;
@@ -18360,8 +19396,16 @@ function bindDashboardFilterToExistingParams(filter, value, block, sqlParams, va
     }
     return [];
 }
-function resolveDashboardFilterBinding(filter, block) {
+function resolveDashboardFilterBinding(filter, block, tileFilterBindings = []) {
     const candidates = uniqueDashboardStrings([filter.id, filter.bindsTo ?? '']).map(normalizeDashboardFilterName);
+    for (const entry of tileFilterBindings ?? []) {
+        const mode = entry.mode ?? (entry.binding ? 'predicate' : undefined);
+        if (mode === 'predicate'
+            && entry.binding
+            && !entry.unsupportedReason
+            && candidates.includes(normalizeDashboardFilterName(entry.filter)))
+            return entry.binding;
+    }
     for (const entry of block.filterBindings ?? []) {
         if (candidates.includes(normalizeDashboardFilterName(entry.filter)))
             return entry.binding;
@@ -18405,6 +19449,13 @@ function buildDashboardFilterPredicate(input) {
     const values = Array.isArray(input.value) ? input.value.filter((item) => !isEmptyDashboardFilterValue(item)) : [input.value];
     if (values.length === 0)
         return null;
+    if (input.filterType === 'search' && values.length === 1) {
+        const search = String(values[0] ?? '').trim();
+        if (!search)
+            return null;
+        const param = addDashboardFilterParam(input, 'contains', `%${search}%`);
+        return `LOWER(${input.expression}) LIKE LOWER($${param.position})`;
+    }
     if (values.length === 1) {
         const param = addDashboardFilterParam(input, 'value', values[0]);
         return `${input.expression} = $${param.position}`;
@@ -19825,14 +20876,224 @@ 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',
     'semantic_compose_failed',
     '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,
@@ -20383,7 +21644,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 {
@@ -20469,10 +21733,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,
@@ -21456,22 +22721,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.
@@ -21482,7 +22813,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(),
     };
 }