@duckcodeailabs/dql-agent 1.6.6 → 1.6.8

package/dist/answer-loop.js

@@ -15,6 +15,7 @@
  * full pipeline.
  */
 import { buildSkillBlockHints, buildSkillsPrompt } from './skills/loader.js';
+import { validateSqlAgainstLocalContext } from './metadata/sql-context-validation.js';
 const CERTIFIED_HIT_THRESHOLD = 0.18;
 const HARD_NEGATIVE_RATIO = 0.5;
 const EXECUTABLE_ARTIFACT_KINDS = ['block', 'dashboard', 'app', 'notebook'];
@@ -52,7 +53,16 @@ export async function answer(input) {
     const intent = catalogRoute ? agentIntentFromCatalogRoute(catalogRoute) : fallbackIntent;
     // Stage 1: certified artifact match. Blocks can be executed; dashboards,
     // Apps, and notebooks are returned as governed citations/navigation targets.
-    const artifactHit = shouldUseCertifiedRoute(catalogRoute, intent)
+    const drilldownCertifiedHit = input.followUp?.kind === 'drilldown'
+        ? pickCertifiedDrilldownArtifact({
+            executableArtifactHits,
+            question,
+            followUp: input.followUp,
+            excludedArtifactIds,
+            kg,
+        })
+        : null;
+    const artifactHit = drilldownCertifiedHit ?? (shouldUseCertifiedRoute(catalogRoute, intent)
         ? certifiedHitFromContextPack(input.contextPack, kg)
             ?? pickCertifiedArtifact({
                 artifactHits,
@@ -63,7 +73,7 @@ export async function answer(input) {
                 excludedArtifactIds,
                 kg,
             })
-        : null;
+        : null);
     if (artifactHit) {
         let result;
         let executionError;
@@ -110,6 +120,10 @@ export async function answer(input) {
             result,
             executionError,
             sql: result?.sql,
+            trustLabel: input.contextPack?.trustLabel ?? 'certified',
+            sourceCertifiedBlock: artifactHit.node.kind === 'block' ? artifactHit.node.name : undefined,
+            contextPackId: input.contextPack?.id,
+            selectedEvidence: input.contextPack?.evidenceRoles?.slice(0, 12),
             citations,
             memoryContext: input.memoryContext,
             analysisPlan,
@@ -206,11 +220,12 @@ export async function answer(input) {
         question,
         intent,
         schemaContext: input.schemaContext ?? [],
+        followUp: input.followUp,
+        contextPack: input.contextPack,
     }) ?? buildContextPackAwareProposal({
         question,
         intent,
         contextPack: input.contextPack,
-        followUp: input.followUp,
     });
     let proposed = '';
     let parsed;
@@ -277,6 +292,60 @@ export async function answer(input) {
             providerUsed: provider.name,
         };
     }
+    const contextValidation = validateSqlAgainstLocalContext(parsed.sql, input.contextPack, {
+        question,
+        intent,
+        filterValues: input.followUp?.filters,
+    });
+    if (!contextValidation.ok) {
+        const text = `I could not safely prepare this generated SQL from the inspected context. ${contextValidation.error}`;
+        const analysisPlan = buildAnalysisPlan({
+            question,
+            intent,
+            routeReason: catalogRoute?.reason ?? 'Generated SQL failed metadata context validation before preview execution or draft capture.',
+            selectedNodes: contextNodes,
+            schemaContext: input.schemaContext ?? [],
+            sql: parsed.sql,
+            suggestedViz: parsed.viz ?? 'table',
+            assumptions: [
+                'Generated SQL was rejected before execution because it did not match inspected metadata context.',
+                ...contextValidation.warnings,
+            ],
+        });
+        return {
+            kind: 'no_answer',
+            sourceTier: 'no_answer',
+            certification: 'analyst_review_required',
+            reviewStatus: 'none',
+            confidence: 0.15,
+            text,
+            answer: text,
+            proposedSql: parsed.sql,
+            sql: parsed.sql,
+            trustLabel: input.contextPack?.trustLabel,
+            sourceCertifiedBlock: followUpSourceBlock?.name ?? input.followUp?.sourceBlockName,
+            contextPackId: input.contextPack?.id,
+            validationWarnings: contextValidation.warnings,
+            selectedEvidence: input.contextPack?.evidenceRoles?.slice(0, 12),
+            citations: [],
+            memoryContext: input.memoryContext,
+            analysisPlan,
+            evidence: buildNoAnswerEvidence({
+                question,
+                reason: contextValidation.error,
+                artifactHits,
+                businessHits,
+                semanticHits,
+                manifestHits,
+                considered,
+                memoryContext: input.memoryContext ?? [],
+                analysisPlan,
+            }),
+            contextPack: input.contextPack,
+            considered,
+            providerUsed: localProposal ? 'schema_planner' : provider.name,
+        };
+    }
     const generatedCitations = [
         ...contextPackCitations(input.contextPack, 4),
         ...contextNodes.slice(0, 4).map((n) => ({
@@ -318,7 +387,7 @@ export async function answer(input) {
                         executionError = retryErr instanceof Error ? retryErr.message : String(retryErr);
                     }
                 }
-                if (executionError && hasUsableRepairSchema(input.schemaContext ?? [])) {
+                if (executionError) {
                     const repairedRaw = await requestSqlRepair({
                         provider,
                         baseMessages: messages,
@@ -331,6 +400,7 @@ export async function answer(input) {
                     const repaired = parseProposal(repairedRaw);
                     if (repaired.sql) {
                         repairAttempts += 1;
+                        parsed.text = repaired.text || parsed.text;
                         parsed.sql = repaired.sql;
                         parsed.viz = repaired.viz ?? parsed.viz;
                         try {
@@ -345,9 +415,6 @@ export async function answer(input) {
             }
         }
     }
-    if (executionError) {
-        parsed.text = composeGeneratedExecutionFailureText(question, executionError);
-    }
     const analysisPlan = buildAnalysisPlan({
         question,
         intent,
@@ -365,19 +432,60 @@ export async function answer(input) {
         ],
         repairAttempts,
     });
+    const validationWarnings = [
+        ...(input.contextPack?.warnings ?? []),
+        ...(executionError ? ['The preview execution error must be reviewed before reuse.'] : []),
+    ];
+    let draftBlock;
+    let draftCaptureError;
+    if (input.captureGeneratedDraft && parsed.sql) {
+        try {
+            draftBlock = await input.captureGeneratedDraft({
+                question,
+                sql: parsed.sql,
+                intent,
+                followUp: input.followUp,
+                contextPack: input.contextPack,
+                sourceBlock: followUpSourceBlock ?? undefined,
+                validationWarnings,
+            });
+        }
+        catch (err) {
+            draftCaptureError = err instanceof Error ? err.message : String(err);
+            validationWarnings.push(`Draft capture failed: ${draftCaptureError}`);
+        }
+    }
+    const sourceCertifiedBlock = followUpSourceBlock?.name ?? input.followUp?.sourceBlockName;
+    const trustExplanation = generatedTrustExplanation({
+        followUp: input.followUp,
+        sourceCertifiedBlock,
+        draftBlock,
+    });
+    const cleanedSummary = cleanGeneratedSummary(parsed.text);
+    const generatedText = trustExplanation
+        ? [trustExplanation, cleanedSummary].filter(Boolean).join('\n\n')
+        : cleanedSummary;
     return {
         kind: 'uncertified',
         sourceTier: activeTier,
         certification: 'ai_generated',
         reviewStatus: 'draft_ready',
         confidence: activeTier === 'semantic_layer' ? 0.72 : 0.55,
-        text: parsed.text,
-        answer: parsed.text,
+        text: generatedText,
+        answer: generatedText,
         proposedSql: parsed.sql,
         sql: parsed.sql,
         result,
         executionError,
         suggestedViz: parsed.viz ?? 'table',
+        draftBlock,
+        draftBlockId: draftBlock?.path,
+        promoteCommand: draftBlock ? `dql certify --from-draft ${draftBlock.path}` : undefined,
+        trustLabel: input.contextPack?.trustLabel,
+        sourceCertifiedBlock,
+        contextPackId: input.contextPack?.id,
+        validationWarnings,
+        selectedEvidence: input.contextPack?.evidenceRoles?.slice(0, 12),
         citations: generatedCitations,
         memoryContext: input.memoryContext,
         analysisPlan,
@@ -427,7 +535,10 @@ Rules:
    proposed SQL. Do not emit INSERT, UPDATE, DELETE, CREATE, DROP, ALTER, COPY,
    PRAGMA, SET, or multiple statements.
 8. If the schema is insufficient to answer, say so explicitly and ask a
-   clarifying question instead of guessing.`;
+   clarifying question instead of guessing.
+9. Write directly to the analyst. Do not say "the user is asking", "the user
+   requested", "I will generate", or describe internal routing. State the
+   answer, the certified context used, and the review requirement.`;
 function renderContextPrompt(blocks, businessContext, others, activeTier, memoryContext, extraContext, followUp, schemaContext = [], intent = 'ad_hoc_analysis', contextPack) {
     const intentSection = `## Routing intent\n\nintent: ${intent}\n${intent === 'exact_certified_lookup'
         ? 'Use a certified artifact only if it exactly answers the question.'
@@ -503,9 +614,6 @@ function renderContextPackForPrompt(contextPack) {
     const allowed = contextPack.allowedSqlContext?.relations.length
         ? `\nAllowed SQL relations:\n${contextPack.allowedSqlContext.relations.slice(0, 12).map((relation) => `- ${relation.relation}: ${relation.columns.slice(0, 24).map((column) => column.name).join(', ') || '(columns unavailable)'}`).join('\n')}`
         : '';
-    const sourceSql = contextPack.allowedSqlContext?.sourceBlockSql.length
-        ? `\nSource block SQL for review-required drafts:\n${contextPack.allowedSqlContext.sourceBlockSql.slice(0, 4).map((source) => `- ${source.name}${source.status ? ` (${source.status})` : ''}:\n${indentSqlForPrompt(source.sql)}`).join('\n')}`
-        : '';
     return [
         `context_pack_id: ${contextPack.id}`,
         `trust_label: ${contextPack.trustLabel}`,
@@ -513,14 +621,9 @@ function renderContextPackForPrompt(contextPack) {
         warnings.trim(),
         `Selected evidence:\n${objects || '- none'}`,
         allowed.trim(),
-        sourceSql.trim(),
         conflicts.trim(),
     ].filter(Boolean).join('\n');
 }
-function indentSqlForPrompt(sql) {
-    const normalized = sql.trim().slice(0, 1600);
-    return normalized.split(/\r?\n/).map((line) => `  ${line}`).join('\n');
-}
 function contextPackCitations(contextPack, limit) {
     if (!contextPack)
         return [];
@@ -639,6 +742,30 @@ function renderFollowUpContext(followUp) {
         : 'routing rule: reuse the prior certified block when the user asks a generic follow-up.';
     return [...parts, rule].join('\n');
 }
+function generatedTrustExplanation(input) {
+    if (input.followUp?.kind !== 'drilldown')
+        return undefined;
+    const source = input.sourceCertifiedBlock
+        ? ` I used the certified \`${input.sourceCertifiedBlock}\` block for the business definition,`
+        : ' I used certified context where available,';
+    const filters = [
+        ...(input.followUp.filters ?? []),
+        ...(input.followUp.dimensions ?? []),
+    ];
+    const grain = filters.length ? ` at the requested ${filters.join('/')} grain` : ' at the requested drilldown grain';
+    const draft = input.draftBlock
+        ? ` The draft was saved at \`${input.draftBlock.path}\` for review.`
+        : ' The generated SQL still needs analyst review before certification.';
+    return `This is an uncertified drilldown.${source} then generated new SQL${grain}.${draft}`;
+}
+function cleanGeneratedSummary(text) {
+    return text
+        .trim()
+        .replace(/^(?:the user (?:is asking|asked|wants|requested)[^.]*\.\s*)+/i, '')
+        .replace(/\s*(?:therefore,\s*)?i will generate review-required sql[^.]*\.\s*/gi, ' ')
+        .replace(/\s*(?:therefore,\s*)?i will generate[^.]*\.\s*/gi, ' ')
+        .trim();
+}
 /**
  * Public for tests. Pulls the first ```sql block and an optional Viz: line
  * out of an LLM response.
@@ -658,6 +785,10 @@ export function parseProposal(raw) {
 function buildSchemaAwareProposal(input) {
     if (!isGeneratedAgentIntent(input.intent))
         return undefined;
+    const schemaContext = schemaContextWithAllowedSqlContext(input.schemaContext, input.contextPack);
+    const drilldownProposal = buildMatchedEntityDrilldownProposal({ ...input, schemaContext });
+    if (drilldownProposal)
+        return drilldownProposal;
     if (isFilteredEntityQuestion(input.question))
         return undefined;
     const lower = input.question.toLowerCase();
@@ -666,7 +797,7 @@ function buildSchemaAwareProposal(input) {
         && !/\b(order details|specific orders|each order|all orders|order line|line item)\b/.test(lower);
     if (!asksForCustomerPerformance)
         return undefined;
-    const customers = findSchemaTable(input.schemaContext, ['customers', 'customer']);
+    const customers = findSchemaTable(schemaContext, ['customers', 'customer']);
     if (!customers)
         return undefined;
     const customerName = findSchemaColumn(customers, ['customer_name', 'name', 'full_name']);
@@ -688,7 +819,7 @@ function buildSchemaAwareProposal(input) {
         };
     }
     const customerId = findSchemaColumn(customers, ['customer_id', 'id']);
-    const orders = findSchemaTable(input.schemaContext, ['orders', 'order']);
+    const orders = findSchemaTable(schemaContext, ['orders', 'order']);
     if (!orders || !customerName || !customerId)
         return undefined;
     const orderCustomerId = findSchemaColumn(orders, ['customer_id', 'customer']);
@@ -713,20 +844,305 @@ function buildSchemaAwareProposal(input) {
         viz: 'table',
     };
 }
+function buildMatchedEntityDrilldownProposal(input) {
+    if (input.intent !== 'entity_drilldown' && input.followUp?.kind !== 'drilldown')
+        return undefined;
+    const table = pickDrilldownTable(input.schemaContext, input.question, input.followUp);
+    if (!table)
+        return undefined;
+    const dimension = inferDrilldownDimension(table, input.question, input.followUp);
+    if (!dimension)
+        return undefined;
+    const entityFilters = matchedEntityFiltersForQuestion(table, input.question, input.followUp);
+    if (entityFilters.length === 0)
+        return undefined;
+    if (entityFilters.some((filter) => namesEqualLoose(filter.column, dimension)))
+        return undefined;
+    const sourceSql = selectSourceBlockSql(input.contextPack, input.followUp?.sourceBlockName);
+    const metric = inferDrilldownMetric(table, input.question, sourceSql);
+    if (!metric)
+        return undefined;
+    const timePredicates = drilldownTimePredicates({
+        question: input.question,
+        followUp: input.followUp,
+        table,
+        sourceSql,
+    });
+    if (mentionsRelativeTime(input.question, input.followUp) && timePredicates.length === 0)
+        return undefined;
+    const predicates = [
+        ...entityFilters.map((filter) => `${sqlIdentifier(filter.column)} = ${sqlStringLiteral(filter.value)}`),
+        ...timePredicates,
+    ];
+    const where = predicates.length ? [`WHERE ${predicates.join(' AND ')}`] : [];
+    return {
+        text: [
+            `Prepared a review-required ${humanizeIdentifier(dimension)} drilldown from inspected metadata.`,
+            `The entity filter uses ${entityFilters.map((filter) => `${filter.column} = ${filter.value}`).join(', ')} from matched sample values.`,
+            'This result is uncertified until reviewed and promoted.',
+        ].join(' '),
+        sql: [
+            'SELECT',
+            `  ${sqlIdentifier(dimension)} AS ${sqlIdentifier(dimension)},`,
+            `  ${metric.expression} AS ${sqlIdentifier(metric.alias)}`,
+            `FROM ${sqlRelation(table.relation)}`,
+            ...where,
+            `GROUP BY ${sqlIdentifier(dimension)}`,
+            `ORDER BY ${sqlIdentifier(metric.alias)} DESC`,
+            'LIMIT 50',
+        ].join('\n'),
+        viz: 'bar',
+    };
+}
+function schemaContextWithAllowedSqlContext(schemaContext, contextPack) {
+    const byRelation = new Map();
+    for (const table of schemaContext) {
+        byRelation.set(normalizeRelationKey(table.relation), {
+            ...table,
+            columns: table.columns.map((column) => ({ ...column, sampleValues: column.sampleValues?.slice() })),
+        });
+    }
+    for (const relation of contextPack?.allowedSqlContext?.relations ?? []) {
+        const key = normalizeRelationKey(relation.relation);
+        const existing = byRelation.get(key);
+        if (!existing) {
+            byRelation.set(key, {
+                relation: relation.relation,
+                name: relation.name,
+                columns: relation.columns.map((column) => ({
+                    name: column.name,
+                    type: column.type,
+                    description: column.description,
+                    sampleValues: column.sampleValues?.slice(),
+                })),
+                source: relation.source,
+            });
+            continue;
+        }
+        const columns = new Map(existing.columns.map((column) => [column.name.toLowerCase(), column]));
+        for (const column of relation.columns) {
+            const existingColumn = columns.get(column.name.toLowerCase());
+            if (!existingColumn) {
+                existing.columns.push({
+                    name: column.name,
+                    type: column.type,
+                    description: column.description,
+                    sampleValues: column.sampleValues?.slice(),
+                });
+                continue;
+            }
+            existingColumn.sampleValues = uniqueDrilldownStrings([
+                ...(existingColumn.sampleValues ?? []),
+                ...(column.sampleValues ?? []),
+            ]).slice(0, 8);
+            existingColumn.type ??= column.type;
+            existingColumn.description ??= column.description;
+        }
+    }
+    return Array.from(byRelation.values());
+}
+function pickDrilldownTable(schemaContext, question, followUp) {
+    const scored = schemaContext
+        .map((table) => ({
+        table,
+        filters: matchedEntityFiltersForQuestion(table, question, followUp).length,
+        dimension: inferDrilldownDimension(table, question, followUp) ? 1 : 0,
+        measure: inferDrilldownMetric(table, question, undefined) ? 1 : 0,
+    }))
+        .filter((candidate) => candidate.filters > 0 && candidate.dimension > 0 && candidate.measure > 0)
+        .sort((a, b) => (b.filters + b.dimension + b.measure) - (a.filters + a.dimension + a.measure));
+    return scored[0]?.table;
+}
+function inferDrilldownDimension(table, question, followUp) {
+    const lower = question.toLowerCase();
+    const requested = [
+        ...(followUp?.dimensions ?? []),
+        ...Array.from(lower.matchAll(/\bby\s+([a-z][a-z0-9_ -]{1,40})/g)).map((match) => match[1] ?? ''),
+    ]
+        .flatMap((value) => value.split(/\band\b|,|\//i))
+        .map((value) => value.replace(/\b(last|this|next|previous|prior|current)\s+(day|week|month|quarter|year)\b/gi, '').trim())
+        .filter(Boolean);
+    const direct = findSchemaColumn(table, requested);
+    if (direct)
+        return direct;
+    if (/\bcustomers?\b/.test(lower)) {
+        const customer = findSchemaColumn(table, ['customer', 'customer_name', 'account', 'account_name']);
+        if (customer)
+            return customer;
+    }
+    if (/\bsegments?\b/.test(lower)) {
+        const segment = findSchemaColumn(table, ['segment', 'customer_segment', 'market_segment']);
+        if (segment)
+            return segment;
+    }
+    if (/\bproducts?\b/.test(lower)) {
+        const product = findSchemaColumn(table, ['product', 'product_name', 'sku']);
+        if (product)
+            return product;
+    }
+    if (/\bregions?\b/.test(lower)) {
+        const region = findSchemaColumn(table, ['region', 'market', 'geo']);
+        if (region)
+            return region;
+    }
+    return undefined;
+}
+function matchedEntityFiltersForQuestion(table, question, followUp) {
+    const text = normalizeForEntityMatch([
+        question,
+        ...(followUp?.filters ?? []),
+    ].join(' '));
+    const filters = [];
+    for (const column of table.columns) {
+        for (const sampleValue of column.sampleValues ?? []) {
+            if (isTemporalDrilldownValue(sampleValue))
+                continue;
+            const needle = normalizeForEntityMatch(sampleValue);
+            if (!needle || !text.includes(needle))
+                continue;
+            filters.push({ column: column.name, value: sampleValue });
+        }
+    }
+    return uniqueMatchedEntityFilters(filters);
+}
+function inferDrilldownMetric(table, question, sourceSql) {
+    const sourceMetric = sourceSql ? aggregateMetricFromSourceSql(table, sourceSql) : undefined;
+    if (sourceMetric)
+        return sourceMetric;
+    const lower = question.toLowerCase();
+    const candidates = /\brevenue|arr|mrr|sales\b/.test(lower)
+        ? ['revenue', 'net_revenue', 'gross_revenue', 'amount', 'order_total', 'total_amount', 'sales', 'arr', 'mrr']
+        : ['amount', 'revenue', 'order_total', 'total_amount', 'value', 'spend'];
+    const column = findSchemaColumn(table, candidates);
+    if (!column)
+        return undefined;
+    const alias = /\brevenue|arr|mrr|sales\b/.test(lower) ? 'revenue_total' : `${column}_total`;
+    return {
+        expression: `SUM(${sqlIdentifier(column)})`,
+        alias,
+    };
+}
+function aggregateMetricFromSourceSql(table, sourceSql) {
+    for (const column of table.columns) {
+        const columnPattern = sqlIdentifierPattern(column.name);
+        const aggregatePattern = new RegExp(`\\b(SUM|COUNT|AVG|MIN|MAX)\\s*\\(\\s*(?:["\`]?\\w+["\`]?\\s*\\.\\s*)?(${columnPattern}|\\*)\\s*\\)\\s*(?:AS\\s+(["\`]?\\w+["\`]?))?`, 'i');
+        const match = sourceSql.match(aggregatePattern);
+        if (!match)
+            continue;
+        const fn = (match[1] ?? 'SUM').toUpperCase();
+        const target = match[2] === '*' ? '*' : sqlIdentifier(column.name);
+        const alias = cleanSqlIdentifier(match[3] ?? defaultMetricAlias(fn, column.name));
+        return {
+            expression: `${fn}(${target})`,
+            alias,
+        };
+    }
+    return undefined;
+}
+function drilldownTimePredicates(input) {
+    if (!mentionsRelativeTime(input.question, input.followUp))
+        return [];
+    if (!input.sourceSql)
+        return [];
+    const timeColumns = input.table.columns.map((column) => column.name).filter(isTimeLikeDrilldownColumn);
+    if (timeColumns.length === 0)
+        return [];
+    return extractWherePredicates(input.sourceSql)
+        .map(stripSqlAliasQualifiers)
+        .filter((predicate) => isReusableSqlPredicate(predicate))
+        .filter((predicate) => timeColumns.some((column) => predicateReferencesColumn(predicate, column)))
+        .slice(0, 3);
+}
+function selectSourceBlockSql(contextPack, sourceBlockName) {
+    const sourceSql = contextPack?.allowedSqlContext?.sourceBlockSql ?? [];
+    if (sourceSql.length === 0)
+        return undefined;
+    const preferred = sourceBlockName
+        ? sourceSql.find((source) => namesEqualLoose(source.name, sourceBlockName))
+        : undefined;
+    return (preferred ?? sourceSql.find((source) => source.status === 'certified') ?? sourceSql[0])?.sql;
+}
+function extractWherePredicates(sql) {
+    const match = sql.match(/\bWHERE\b([\s\S]*?)(\bGROUP\s+BY\b|\bHAVING\b|\bORDER\s+BY\b|\bLIMIT\b|$)/i);
+    if (!match)
+        return [];
+    return (match[1] ?? '')
+        .split(/\s+AND\s+/i)
+        .map((part) => part.trim().replace(/^\(+|\)+$/g, '').replace(/\s+/g, ' '))
+        .filter(Boolean);
+}
+function mentionsRelativeTime(question, followUp) {
+    const text = [question, ...(followUp?.filters ?? [])].join(' ');
+    return /\b(last|this|next|previous|prior|current)\s+(day|week|month|quarter|year)\b/i.test(text)
+        || /\b(today|yesterday|tomorrow|ytd|mtd|qtd|wtd)\b/i.test(text);
+}
+function isTimeLikeDrilldownColumn(name) {
+    return /\b(date|time|day|week|month|quarter|year|period|created_at|updated_at)\b/i.test(name);
+}
+function stripSqlAliasQualifiers(predicate) {
+    return predicate.replace(/\b["`]?\w+["`]?\s*\.\s*(["`]?\w+["`]?)/g, '$1');
+}
+function isReusableSqlPredicate(predicate) {
+    if (!predicate || predicate.length > 240)
+        return false;
+    if (/[;]/.test(predicate) || /--|\/\*/.test(predicate))
+        return false;
+    return !/\b(SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|COPY|PRAGMA|SET)\b/i.test(predicate);
+}
+function predicateReferencesColumn(predicate, column) {
+    return new RegExp(`(^|[^\\w])${sqlIdentifierPattern(column)}([^\\w]|$)`, 'i').test(predicate);
+}
+function sqlIdentifierPattern(identifier) {
+    const escaped = escapeRegExp(identifier);
+    return `(?:"${escaped}"|\`${escaped}\`|${escaped})`;
+}
+function sqlStringLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function defaultMetricAlias(fn, column) {
+    if (fn === 'SUM' && /revenue|amount|sales|arr|mrr/i.test(column))
+        return 'revenue_total';
+    return `${column}_${fn.toLowerCase()}`;
+}
+function cleanSqlIdentifier(identifier) {
+    return identifier.replace(/^["`]|["`]$/g, '').trim();
+}
+function namesEqualLoose(a, b) {
+    return cleanSqlIdentifier(a).replace(/[_-]+/g, ' ').toLowerCase() === cleanSqlIdentifier(b).replace(/[_-]+/g, ' ').toLowerCase();
+}
+function normalizeRelationKey(relation) {
+    return relation.replace(/["`]/g, '').replace(/\s*\.\s*/g, '.').toLowerCase().trim();
+}
+function normalizeForEntityMatch(value) {
+    return value.toLowerCase().replace(/[^a-z0-9.%+-]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+function uniqueMatchedEntityFilters(filters) {
+    const seen = new Set();
+    const unique = [];
+    for (const filter of filters) {
+        const key = `${filter.column.toLowerCase()}\0${filter.value.toLowerCase()}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(filter);
+    }
+    return unique;
+}
+function uniqueDrilldownStrings(values) {
+    return Array.from(new Set(values));
+}
+function isTemporalDrilldownValue(value) {
+    return mentionsRelativeTime(value, undefined) || /^\d{4}-\d{2}-\d{2}/.test(value);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 function buildContextPackAwareProposal(input) {
     if (!isGeneratedAgentIntent(input.intent))
         return undefined;
     if (!input.contextPack)
         return undefined;
-    const contextPack = input.contextPack;
     const lower = input.question.toLowerCase();
-    const filteredSourceProposal = buildSourceBlockFilterProposal({
-        question: input.question,
-        contextPack,
-        followUp: input.followUp,
-    });
-    if (filteredSourceProposal)
-        return filteredSourceProposal;
     if (!/\b(least|lowest|fewest|bottom|min(?:imum)?)\b/.test(lower))
         return undefined;
     for (const object of input.contextPack.objects) {
@@ -746,65 +1162,6 @@ function buildContextPackAwareProposal(input) {
     }
     return undefined;
 }
-function buildSourceBlockFilterProposal(input) {
-    const year = extractYearFilterValue(input.question, input.followUp);
-    if (!year)
-        return undefined;
-    const source = preferredSourceBlockSql(input.contextPack, input.followUp?.sourceBlockName);
-    if (!source?.sql.trim())
-        return undefined;
-    const sql = source.sql.trim();
-    const filterColumn = pickTimeFilterColumn(sql);
-    if (!filterColumn)
-        return undefined;
-    return {
-        text: `Generated a review-required ${year} view from certified block "${source.name}" as context. This filters the selected block grain instead of reusing the certified answer directly, so it remains uncertified until reviewed.`,
-        sql: [
-            'SELECT *',
-            'FROM (',
-            indentSubquerySql(stripFinalLimit(sql)),
-            ') AS dql_source',
-            `WHERE ${sqlIdentifier(filterColumn)} = ${year}`,
-            'LIMIT 200',
-        ].join('\n'),
-        viz: 'table',
-    };
-}
-function preferredSourceBlockSql(contextPack, sourceBlockName) {
-    const sources = contextPack.allowedSqlContext?.sourceBlockSql ?? [];
-    const normalizedSource = sourceBlockName ? normalizeSourceName(sourceBlockName) : undefined;
-    if (normalizedSource) {
-        const exact = sources.find((source) => normalizeSourceName(source.name) === normalizedSource);
-        if (exact)
-            return exact;
-    }
-    return sources.find((source) => source.status === 'certified') ?? sources[0];
-}
-function extractYearFilterValue(question, followUp) {
-    const direct = question.match(/\b(19|20)\d{2}\b/)?.[0];
-    if (direct)
-        return direct;
-    const fromFollowUp = followUp?.filters
-        ?.map((filter) => filter.match(/\b(19|20)\d{2}\b/)?.[0])
-        .find(Boolean);
-    return fromFollowUp;
-}
-function pickTimeFilterColumn(sql) {
-    if (/\bseason\b/i.test(sql))
-        return 'season';
-    if (/\byear\b/i.test(sql))
-        return 'year';
-    return undefined;
-}
-function stripFinalLimit(sql) {
-    return sql.replace(/;\s*$/, '').replace(/\s+limit\s+\d+\s*$/i, '').trim();
-}
-function indentSubquerySql(sql) {
-    return sql.split(/\r?\n/).map((line) => `  ${line}`).join('\n');
-}
-function normalizeSourceName(value) {
-    return value.replace(/^block:/i, '').trim().toLowerCase();
-}
 function invertRankingSql(sql) {
     const withoutTrailingSemicolon = sql.replace(/;\s*$/, '').trim();
     const inverted = withoutTrailingSemicolon.replace(/\border\s+by\s+([\s\S]*?)(\blimit\b|$)/i, (match, orderExpr, limitKeyword) => {
@@ -908,6 +1265,40 @@ function pickFirstCertifiedHit(hits, kg, excludedNodeIds, question) {
     }
     return null;
 }
+function pickCertifiedDrilldownArtifact(input) {
+    const requestedTerms = meaningfulTokens([
+        input.question,
+        ...(input.followUp.filters ?? []),
+        ...(input.followUp.dimensions ?? []),
+    ].join(' '));
+    for (const hit of input.executableArtifactHits) {
+        if (hit.score < CERTIFIED_HIT_THRESHOLD)
+            break;
+        if (input.excludedArtifactIds?.has(hit.node.nodeId))
+            continue;
+        if (hit.node.kind !== 'block')
+            continue;
+        if (!isCertifiedHit(hit, input.kg))
+            continue;
+        if (!hasCompatibleCertifiedBlockMatch(input.question, hit.node))
+            continue;
+        if (!hasRequestedDrilldownOverlap(hit.node, requestedTerms))
+            continue;
+        return hit;
+    }
+    return null;
+}
+function hasRequestedDrilldownOverlap(node, requestedTerms) {
+    if (requestedTerms.size === 0)
+        return false;
+    const nodeTerms = meaningfulTokens(certifiedBlockSignalText(node));
+    let overlaps = 0;
+    for (const term of requestedTerms) {
+        if (nodeTerms.has(term))
+            overlaps += 1;
+    }
+    return overlaps >= 2 || (requestedTerms.size === 1 && overlaps === 1);
+}
 function shouldDeferCertifiedArtifactForReviewPath(input) {
     if (!isBreakdownOrDrilldownQuestion(input.question))
         return false;
@@ -1359,26 +1750,12 @@ async function requestSqlRepair(input) {
                 'The generated SQL failed during bounded preview execution.',
                 `Question: ${input.question}`,
                 `Execution error: ${input.executionError}`,
-                'Return only one corrected read-only SQL query in a fenced sql block using only the runtime schema below.',
-                'If the runtime schema is not enough to repair the SQL, return "NEEDS_CONTEXT:" followed by one short missing-context question. Do not propose proxy tables.',
+                'Return one corrected read-only SQL query using only the runtime schema below.',
                 schema,
             ].join('\n\n'),
         },
     ], { signal: input.signal });
 }
-function hasUsableRepairSchema(schemaContext) {
-    return schemaContext.some((table) => table.columns.length > 0);
-}
-function composeGeneratedExecutionFailureText(question, executionError) {
-    const compactError = executionError.replace(/\s+/g, ' ').trim();
-    const shownError = compactError.length > 220 ? `${compactError.slice(0, 217)}...` : compactError;
-    return [
-        `I generated a review-required SQL draft for "${question}", but the bounded preview did not run successfully.`,
-        'I did not switch to a proxy table because that could answer a different question.',
-        `Execution issue: ${shownError}`,
-        'Refresh the runtime schema or fix the source relation/columns, then rerun the draft.',
-    ].join(' ');
-}
 function isRetryableGeneratedSqlError(error) {
     return !/\b(read-only|readonly|select or with|unsafe|delete|insert|update|drop|alter|create|attach|copy|pragma)\b/i.test(error);
 }