@duckcodeailabs/dql-agent 1.14.3-rc.1 → 1.14.4

package/dist/agent-run-engine.js

@@ -7,7 +7,8 @@ import { selectCascadeRunRoute } from "./cascade/route-policy.js";
 import { canUseEngineEscalation, canUseLaneRepair, cascadeBudgetTrace, createCascadeBudgetState, recordEngineEscalation, recordLaneRepair, } from "./cascade/budgets.js";
 import { buildAnalysisQuestionPlan } from "./metadata/analysis-planner.js";
 import { conversationHistoryFromContext, isLikelyClarificationReply, } from "./conversation/snapshot.js";
-import { buildCoverageGap, classifyProviderFailure, } from './analytical-orchestration.js';
+import { buildCoverageGap, classifyProviderFailure, normalizeCanonicalQueryResult, } from './analytical-orchestration.js';
+import { createAskToolKernelV2, createAskV2ExecutionCapabilityV1, isAskV2ExecutionReceiptAuthorizedV1, } from './ask-runtime/ask-agent-runtime-v2.js';
 import { evaluateAnalyticalRequestPolicy } from './analytical-request-policy.js';
 import { frozenRequiredOutputBindingProofsForPlan } from './generated-analytical-proposal.js';
 import { attachAskTraceObserverV1, askTraceObserverForV1, finalizeAgentRunTraceV1, noOpAskTraceObserverV1, recordAuthoritativeRouterDecisionV1, recordAuthoritativePlanFreezeV1, recordEngineTraceEventV1, recordExecutionAttemptSummaryV1, } from './ask-observability/index.js';
@@ -544,12 +545,22 @@ export class AgentRunEngine {
      */
     async decideRoute(request) {
         const requestedAction = requestedModeToAction(request.requestedMode);
+        // An explicitly selected authoritative-V2 Research turn still has to
+        // enter the V2 router once. The old forced-mode shortcut predates the V2
+        // tool kernel and returned the legacy `investigate` decision before the
+        // host could attach the immutable retrieval workspace, so the V2 Research
+        // planner/handler was never reached. This is deliberately narrow: legacy
+        // and shadow Research retain their existing forced-mode behavior, and no
+        // browser-provided value can set this host-owned runtime mode.
+        const authoritativeV2Research = request.askAgentRuntimeMode === 'authoritative_v2'
+            && request.requestedMode === 'research';
         // `ask` constrains the eventual analytical action to a direct answer, but it
         // still needs retrieval-first meaning resolution. Treating it like the SQL,
         // block, or app authoring modes used to bypass the evidence router entirely
         // on the primary Ask surface.
-        if (requestedAction && request.requestedMode !== "ask")
+        if (requestedAction && request.requestedMode !== "ask" && !authoritativeV2Research) {
             return buildIntentDecision(request);
+        }
         if (this.router) {
             try {
                 const routed = await this.router.decide(request);
@@ -604,7 +615,12 @@ export class AgentRunEngine {
         catch {
             traceObserver = noOpAskTraceObserverV1;
         }
-        request = attachAskTraceObserverV1({ ...request }, traceObserver);
+        // The engine-owned ID is available before retrieval/routing. Bind it to
+        // this internal request object now so request-scoped host capabilities
+        // (for example one cold-literal probe) can never be minted against an
+        // anonymous or browser-supplied identity. Public ingress still strips any
+        // caller-provided `runId` before the engine chooses this value.
+        request = attachAskTraceObserverV1({ ...request, runId }, traceObserver);
         // Continuity is relationship evidence, not new routing input. Keep only
         // stable run IDs and one-way fingerprints so a trace can explain why this
         // turn reused a clarification/result/derived plan without persisting chat
@@ -694,6 +710,23 @@ export class AgentRunEngine {
                 artifacts: [...progress.artifacts],
                 evaluations: [...progress.evaluations],
                 events: [...progress.events],
+                ...(progress.analyticalTaskOutcomes
+                    ? { analyticalTaskOutcomes: progress.analyticalTaskOutcomes.map((outcome) => ({
+                            ...outcome,
+                            ...(outcome.dependencyTaskIds ? { dependencyTaskIds: [...outcome.dependencyTaskIds] } : {}),
+                        })) }
+                    : {}),
+                ...(progress.analyticalTaskOutcomeSummary
+                    ? {
+                        analyticalTaskOutcomeSummary: {
+                            ...progress.analyticalTaskOutcomeSummary,
+                            successfulTaskIds: [...progress.analyticalTaskOutcomeSummary.successfulTaskIds],
+                            failedTaskIds: [...progress.analyticalTaskOutcomeSummary.failedTaskIds],
+                            dependencyBlockedTaskIds: [...progress.analyticalTaskOutcomeSummary.dependencyBlockedTaskIds],
+                        },
+                    }
+                    : {}),
+                ...(progress.askAnalystState ? { askAnalystState: progress.askAnalystState } : {}),
             };
             checkpointQueue = checkpointQueue.then(async () => {
                 try {
@@ -760,6 +793,23 @@ export class AgentRunEngine {
                 ...(clarificationContinuation ? { clarificationResolved: true } : {}),
             },
         });
+        // AskAnalystRuntimeV1 emits typed state checkpoints after framing and each
+        // bounded tool action. They are local/restart material only and are never
+        // exported through the content-free trace projection.
+        // Checkpointing adds a callback after the observer was attached above.
+        // Preserve the non-enumerable trace observer through this immutable update:
+        // otherwise the authoritative runtime can record its router state while
+        // the later provider/compiler/execution adapter sees a no-op observer.
+        // That made a successfully executed deterministic physical program appear
+        // to have no SQL generation, validation, authorization, or execution in
+        // the same trace.
+        request = attachAskTraceObserverV1({
+            ...request,
+            askAnalystCheckpoint: (state) => {
+                progress.askAnalystState = state;
+                persistProgress();
+            },
+        }, traceObserver);
         // This check is intentionally before route selection.  A restricted direct
         // disclosure must not be embedded, retrieved, sent to a provider, value
         // probed, or compiled merely to explain why it cannot be answered.
@@ -871,7 +921,8 @@ export class AgentRunEngine {
             run.diagnosticReceiptV2 = diagnosticReceiptV2ForRun(run);
             run.diagnosticReceiptV3 = diagnosticReceiptV3ForRun(run);
             run.diagnosticReceiptV4 = diagnosticReceiptV4ForRun(run);
-            run.artifacts = attachDiagnosticReceipt(run.artifacts, run.diagnosticReceipt, run.diagnosticReceiptV2, run.diagnosticReceiptV3, run.diagnosticReceiptV4);
+            attachAskAnalystRuntimeReceipt(run, request.askAgentRuntimeMode);
+            run.artifacts = attachDiagnosticReceipt(run.artifacts, run.diagnosticReceipt, run.diagnosticReceiptV2, run.diagnosticReceiptV3, run.diagnosticReceiptV4, run.diagnosticReceiptV5, run.diagnosticReceiptV6, run.diagnosticReceiptV7, run.diagnosticReceiptV8);
             // Observability is deliberately finalized only after the authoritative
             // receipt exists, and before the ordinary run store persists its compact
             // reference. A local trace write failure never changes this outcome.
@@ -900,6 +951,31 @@ export class AgentRunEngine {
                     source: "heuristic",
                 }
                 : await awaitWithAbort(this.decideRoute(request), request.signal);
+            // V2 owns interpretation and pre-freeze route progression in its bounded
+            // tool runtime.  Carry only its host-created state to the executor; no
+            // public request path can manufacture this handoff.  The engine remains
+            // the owner of policy, plan freeze, execution and persistence.
+            if (routeDecision.askAgentV2Decision) {
+                // `ASK_TRACE_OBSERVER_V1` is deliberately non-enumerable.  This V2
+                // carrier update is the first immutable request replacement after
+                // routing, so a plain spread would detach the physical provider
+                // preflight from the root trace precisely on authoritative V2 turns.
+                // Keep the observer with the server-owned state; no client value can
+                // attach it.
+                const v2ExecutionCapability = routeDecision.askAgentV2Decision.mode === 'authoritative_v2'
+                    ? createAskV2ExecutionCapabilityV1({
+                        id: randomUUID(),
+                        runId,
+                        state: routeDecision.askAgentV2Decision.state,
+                    })
+                    : undefined;
+                request = attachAskTraceObserverV1({
+                    ...request,
+                    askAgentRuntimeMode: routeDecision.askAgentV2Decision.mode,
+                    askAgentV2State: routeDecision.askAgentV2Decision.state,
+                    ...(v2ExecutionCapability ? { askAgentV2ExecutionCapability: v2ExecutionCapability } : {}),
+                }, traceObserver);
+            }
             routeDecision = enforceOrdinaryAnalyticalPlanBoundary(request, routeDecision);
             traceObserver.finishSpan(classifySpan, { outcome: 'ok', reasonCode: 'route_selected' });
             // Router/cascade evidence is captured after its authoritative decision
@@ -909,11 +985,18 @@ export class AgentRunEngine {
             const defaultRoute = answerAnywayRoute(constrainRouteForAudience(selectRoute(request, routeDecision), audience), request, audience, routeDecision);
             const authoritativeAsk = routeDecision.resolvedAnalyticalPlan?.mode === 'authoritative'
                 && requestedMode !== 'research';
-            const activePlanner = authoritativeAsk
+            // AskAnalystRuntimeV1 owns the single immutable task program. The
+            // engine may still use the legacy deterministic/LLM planners for every
+            // other surface, but it must never replace a runtime-frozen Ask task
+            // with a new generic one-step interpretation.
+            const runtimeFrozenPlan = authoritativeAsk
+                ? routeDecision.askAnalystDecision?.frozenPlan
+                : undefined;
+            const activePlanner = authoritativeAsk && !runtimeFrozenPlan
                 ? createDeterministicAgentRunPlanner()
                 : this.planner;
             const planningSignal = request.runBudget?.hardSignal ?? request.signal;
-            plan = await awaitWithAbort(Promise.resolve(activePlanner.plan({
+            plan = runtimeFrozenPlan ?? await awaitWithAbort(Promise.resolve(activePlanner.plan({
                 request,
                 routeDecision,
                 defaultRoute,
@@ -933,6 +1016,38 @@ export class AgentRunEngine {
                 ...step,
                 route: answerAnywayRoute(constrainRouteForAudience(step.route, audience), request, audience, routeDecision),
             }));
+            // A multi-task authoritative Ask has one frozen task queue.  V2 task
+            // outcome receipts may retain an independent sibling when another task
+            // fails; persisted pre-V2 decisions deliberately retain the historical
+            // all-or-nothing aggregate below.  Neither mode may silently omit a
+            // task or substitute a freshly parsed child graph.
+            const authoritativeTaskExecutions = authoritativeAsk
+                ? routeDecision.askAnalystDecision?.taskExecutions ?? []
+                : [];
+            const initialTaskOutcomes = authoritativeAsk
+                ? routeDecision.askAnalystDecision?.taskOutcomes ?? []
+                : [];
+            const initialTaskOutcomeSummary = authoritativeAsk
+                ? routeDecision.askAnalystDecision?.taskOutcomeSummary
+                : undefined;
+            const authoritativePartialOutcomeMode = Boolean(initialTaskOutcomeSummary
+                && initialTaskOutcomeSummary.taskCount > 1);
+            const authoritativeCompoundAsk = authoritativeTaskExecutions.length > 1 || authoritativePartialOutcomeMode;
+            if (initialTaskOutcomes.length > 0)
+                progress.analyticalTaskOutcomes = initialTaskOutcomes;
+            if (initialTaskOutcomeSummary)
+                progress.analyticalTaskOutcomeSummary = initialTaskOutcomeSummary;
+            const authoritativeTaskIds = new Set(authoritativeTaskExecutions.map((task) => task.taskId));
+            const authoritativeQueueIds = queue
+                .map((step) => step.askAnalystTaskId)
+                .filter((taskId) => Boolean(taskId));
+            const authoritativeQueueValid = !authoritativeCompoundAsk || (queue.length === authoritativeTaskExecutions.length
+                && authoritativeQueueIds.length === authoritativeTaskExecutions.length
+                && new Set(authoritativeQueueIds).size === authoritativeQueueIds.length
+                && authoritativeQueueIds.every((taskId) => authoritativeTaskIds.has(taskId)));
+            if (!authoritativeQueueValid) {
+                throw Object.assign(new Error('The authoritative Ask runtime did not supply one frozen execution step for every executable task.'), { code: 'ASK_ANALYST_TASK_PLAN_MISMATCH' });
+            }
             const budgets = createCascadeBudgetState(this.budgetModel);
             let stepCount = 0;
             let finalStep;
@@ -943,11 +1058,73 @@ export class AgentRunEngine {
             // non-answer step (e.g. a research/draft step that emits only an artifact)
             // must not drop the data answer an earlier step already computed.
             let bestAnswerResult;
-            while (queue.length > 0 && stepCount < this.maxSteps) {
+            /** Dependencies skipped after a parent execution failure. */
+            const runtimeDependencyBlockedTaskIds = new Map();
+            // Compiler receipts describe what can be attempted, never what has
+            // executed.  Persist an execution-only aggregate before task 1 starts,
+            // and again after every task reaches a terminal step.  That makes an
+            // interrupted local run recoverable without advertising compiled tasks
+            // as completed work.
+            const checkpointAuthoritativeTaskOutcomes = () => {
+                if (!authoritativePartialOutcomeMode)
+                    return;
+                const aggregate = aggregateAuthoritativeTaskOutcomes({
+                    initialTaskOutcomes,
+                    taskExecutions: authoritativeTaskExecutions,
+                    steps: executedSteps,
+                    dependencyBlockedTaskIds: runtimeDependencyBlockedTaskIds,
+                    taskCount: initialTaskOutcomeSummary?.taskCount,
+                    finalized: false,
+                });
+                progress.analyticalTaskOutcomes = aggregate.outcomes;
+                progress.analyticalTaskOutcomeSummary = aggregate.summary;
+                progress.steps = [...executedSteps];
+                persistProgress();
+            };
+            checkpointAuthoritativeTaskOutcomes();
+            // The runtime bounds ordinary Ask to three accepted tasks.  Once it
+            // accepts a compound mission, every frozen child must receive one
+            // execution attempt even when the generic engine's normal plan cap is
+            // smaller.  Do not turn the cap into a silent partial answer.
+            const executionStepLimit = authoritativeCompoundAsk ? queue.length : this.maxSteps;
+            while (queue.length > 0 && stepCount < executionStepLimit) {
                 const planned = queue.shift();
                 stepCount += 1;
                 const route = planned.route;
                 const stepId = `${runId}:step:${stepCount}`;
+                // A compound authoritative Ask carries one immutable compiler handoff
+                // per accepted task.  Swap it in at the execution boundary rather than
+                // letting task-2 inherit task-1's frame, candidates, or cascade.
+                const taskExecution = authoritativeAsk && planned.askAnalystTaskId
+                    ? routeDecision.askAnalystDecision?.taskExecutions?.find((task) => task.taskId === planned.askAnalystTaskId)
+                    : undefined;
+                const taskQuestion = taskExecution
+                    ? taskExecution.state.mission.tasks.find((task) => task.id === taskExecution.taskId)?.question
+                        ?? planned.goal
+                    : undefined;
+                const taskRequest = taskExecution && taskQuestion
+                    ? attachAskTraceObserverV1({
+                        ...request,
+                        // Every compiler and executor sees only the frozen child
+                        // question.  The submitted parent remains captured by the root
+                        // trace observer and is restored onto the persisted run below.
+                        question: taskQuestion,
+                        askAnalystTaskChild: {
+                            version: 1,
+                            taskId: taskExecution.taskId,
+                            question: taskQuestion,
+                            instructions: [...planned.successCriteria],
+                        },
+                        askAnalystState: taskExecution.state,
+                        askAnalystProgram: taskExecution.program,
+                        askAnalystMeaningResolution: taskExecution.meaningResolution,
+                        askAnalystTierReadiness: taskExecution.tierReadiness,
+                        hostRequirementSeed: taskExecution.requirementSeed,
+                    }, traceObserver)
+                    : request;
+                let taskRouteDecision = taskExecution
+                    ? taskScopedRouteDecision(routeDecision, taskExecution)
+                    : routeDecision;
                 emit({
                     type: "step.started",
                     message: `Step ${stepCount}: ${planned.goal}`,
@@ -955,23 +1132,83 @@ export class AgentRunEngine {
                     payload: { stepId, index: stepCount, goal: planned.goal, successCriteria: planned.successCriteria },
                 });
                 const resolvedPlanShadow = stepCount === 1
-                    ? compareResolvedPlanShadow(routeDecision, route)
+                    ? compareResolvedPlanShadow(taskRouteDecision, route)
                     : undefined;
                 emit({
                     type: "route.decided",
                     message: stepCount === 1
-                        ? routeDecision.reason
+                        ? taskRouteDecision.reason
                         : `Routed step ${stepCount} to ${route.replaceAll("_", " ")}.`,
                     route,
                     payload: stepCount === 1
                         ? {
-                            ...routeDecision,
+                            ...taskRouteDecision,
                             ...(resolvedPlanShadow
                                 ? { resolvedPlanShadow }
                                 : {}),
                         }
                         : { route, goal: planned.goal },
                 });
+                // V2 compound Ask treats a task dependency as an execution boundary,
+                // not a reason to reinterpret or replan the child.  A dependent child
+                // may use its predecessor only after that predecessor produced an
+                // accepted result.  Independent siblings continue to their own frozen
+                // programs after a failure; this branch is deliberately restricted to
+                // the additive V2 receipt so pre-V2 persisted compound runs preserve
+                // their historical all-or-nothing behavior.
+                const dependencyTaskIds = taskExecution
+                    ? taskExecution.dependencyTaskIds
+                        ?? taskExecution.state.mission.tasks.find((task) => task.id === taskExecution.taskId)?.dependencies
+                        ?? []
+                    : [];
+                const unmetDependencyIds = authoritativePartialOutcomeMode && taskExecution
+                    ? dependencyTaskIds.filter((dependencyTaskId) => !hasAcceptedAuthoritativeTaskResult(executedSteps.find((step) => step.askAnalystTaskId === dependencyTaskId)))
+                    : [];
+                if (taskExecution && unmetDependencyIds.length > 0) {
+                    runtimeDependencyBlockedTaskIds.set(taskExecution.taskId, unmetDependencyIds);
+                    const summary = 'This task was not executed because a required task did not complete successfully.';
+                    const dependencyStep = {
+                        id: stepId,
+                        index: stepCount,
+                        route,
+                        ...(planned.askAnalystTaskId ? { askAnalystTaskId: planned.askAnalystTaskId } : {}),
+                        goal: planned.goal,
+                        successCriteria: planned.successCriteria,
+                        status: 'blocked',
+                        attempts: 0,
+                        summary,
+                        evaluations: [{
+                                id: `task-dependency:${taskExecution.taskId}`,
+                                label: 'Task dependency',
+                                passed: false,
+                                severity: 'blocking',
+                                message: summary,
+                                evidence: { dependencyTaskIds: unmetDependencyIds },
+                            }],
+                        artifacts: [],
+                    };
+                    executedSteps.push(dependencyStep);
+                    const dependencyOutcome = {
+                        status: 'blocked',
+                        trustState: 'blocked',
+                        artifacts: [],
+                        stopReason: 'blocked',
+                        summary,
+                    };
+                    finalStep = dependencyStep;
+                    finalResult = { status: 'blocked', trustState: 'blocked', summary };
+                    finalOutcome = dependencyOutcome;
+                    checkpointAuthoritativeTaskOutcomes();
+                    emit({
+                        type: 'step.completed',
+                        message: `Step ${stepCount} dependency blocked.`,
+                        route,
+                        status: 'blocked',
+                        trustState: 'blocked',
+                        payload: { stepId, status: 'blocked', dependencyTaskIds: unmetDependencyIds },
+                    });
+                    continue;
+                }
                 let attempt = 0;
                 let repairHint;
                 let priorEvaluations;
@@ -996,9 +1233,9 @@ export class AgentRunEngine {
                     // preflight before any executor result exists.
                     result = await this.executeRoute({
                         runId,
-                        request,
+                        request: taskRequest,
                         route,
-                        routeDecision,
+                        routeDecision: taskRouteDecision,
                         maxRepairAttempts: budgets.limits.lane.execution,
                         attempt,
                         stepGoal: planned.goal,
@@ -1014,23 +1251,61 @@ export class AgentRunEngine {
                     // semantic plan into generated work (or vice versa) after execution
                     // has started. Keep this guard in the engine as well as host adapters
                     // so an injected/legacy executor cannot redefine durable provenance.
-                    const planWasFrozen = routeDecision.analyticalCascadeDecision?.planFrozen === true;
-                    routeDecision = applyExploratoryExecutionFreeze(routeDecision, result.analyticalExecutionFreeze);
-                    routeDecision = applyExploratoryExecutionFreeze(routeDecision, result.analyticalExecutionRepairFreeze);
+                    const planWasFrozen = taskRouteDecision.analyticalCascadeDecision?.planFrozen === true;
+                    taskRouteDecision = applyExploratoryExecutionFreeze(taskRouteDecision, result.analyticalExecutionFreeze);
+                    taskRouteDecision = applyExploratoryExecutionFreeze(taskRouteDecision, result.analyticalExecutionRepairFreeze);
+                    // Legacy/non-authoritative execution has no task-local durable
+                    // decision. Promote the validated host authorization receipts back
+                    // to the run-level decision so the persisted run and trace retain
+                    // the same immutable exploratory handoff that the executor used.
+                    // Authoritative compound Ask keeps its outer decision as a turn
+                    // summary and records each task-local handoff independently.
+                    // A single authoritative task is still the whole Ask answer.  Its
+                    // host-issued exploratory execution freeze must be promoted to the
+                    // outer decision so V3/V6 persistence and the trace retain the same
+                    // capability receipt that authorized SQL.  Compound Ask keeps each
+                    // frozen child isolated under its task execution receipts.
+                    if (!taskExecution || (routeDecision.askAnalystDecision?.taskExecutions?.length ?? 0) === 1) {
+                        routeDecision = taskRouteDecision;
+                    }
                     // The router froze the exploratory plan before SQL generation. The
                     // host receipt below only authorizes this exact SQL/target against
                     // that immutable plan; it never creates a second freeze transition.
-                    if (!planWasFrozen && routeDecision.analyticalCascadeDecision?.planFrozen) {
-                        recordAuthoritativePlanFreezeV1(traceObserver, routeDecision.analyticalCascadeDecision);
+                    if (!planWasFrozen && taskRouteDecision.analyticalCascadeDecision?.planFrozen) {
+                        recordAuthoritativePlanFreezeV1(traceObserver, taskRouteDecision.analyticalCascadeDecision);
                     }
-                    result = preserveFrozenAnalyticalRoute(route, routeDecision, result);
-                    result = consumeRepeatedClarificationSelection(request, routeDecision, result);
+                    result = preserveFrozenAnalyticalRoute(route, taskRouteDecision, result);
+                    result = consumeRepeatedClarificationSelection(taskRequest, taskRouteDecision, result);
                     if (result.analyticalTurnPlan)
                         progress.analyticalTurnPlan = result.analyticalTurnPlan;
                     if (result.analyticalTaskOutcomes)
                         progress.analyticalTaskOutcomes = result.analyticalTaskOutcomes;
                     persistProgress();
-                    evaluations = this.evaluate({ route, request, routeDecision, result, attempt });
+                    // A terminal V2 `finish_answer` is accepted only after the host has
+                    // frozen one snapshot-bound plan and recorded an actual execution
+                    // result.  The generic evaluator predates that runtime and can
+                    // otherwise request a legacy replan of the very same certified
+                    // artifact.  That second invocation is correctly refused by the
+                    // V2 kernel as `POST_FREEZE_REPAIR_REQUIRED`, but it also discards
+                    // the valid result which already ran.  Preserve the successful V2
+                    // boundary here; terminal V2 errors still flow through the ordinary
+                    // evaluation and blocked-outcome path below.
+                    const acceptedV2TerminalState = acceptedAskAgentV2TerminalState(taskRequest, taskRouteDecision, result, runId);
+                    // Run the generic gates for a successful V2 terminal too — but with
+                    // their REPAIRS disarmed. Replacing the whole array with the single
+                    // terminal receipt meant the answer-shape gate never inspected a V2
+                    // result: a run whose executed columns did not match the question's
+                    // required outputs shipped as "1 check passed". The repair hooks
+                    // stay stripped for the reason documented above — the legacy replan
+                    // would discard the validated result — so a failed gate REPORTS
+                    // (status/summary see it) without ever re-planning the frozen plan.
+                    evaluations = acceptedV2TerminalState
+                        ? [
+                            ...this.evaluate({ route, request: taskRequest, routeDecision: taskRouteDecision, result, attempt })
+                                .map(disarmRepairForV2Terminal),
+                            acceptedAskAgentV2TerminalEvaluation(acceptedV2TerminalState),
+                        ]
+                        : this.evaluate({ route, request: taskRequest, routeDecision: taskRouteDecision, result, attempt });
                     for (const evaluation of evaluations) {
                         emit({
                             type: "evaluation.recorded",
@@ -1052,7 +1327,7 @@ export class AgentRunEngine {
                     // A frozen analytical plan has one route and no downstream planner,
                     // rematch, route escalation, or whole-answer regeneration authority.
                     // Typed server-issued repair is a separate derived run.
-                    if (authoritativeAsk || routeDecision.analyticalCascadeDecision?.planFrozen === true) {
+                    if (authoritativeAsk || taskRouteDecision.analyticalCascadeDecision?.planFrozen === true) {
                         stepStatus = 'needs_review';
                         break;
                     }
@@ -1069,7 +1344,7 @@ export class AgentRunEngine {
                         artifacts: result.artifacts ?? [],
                     };
                     const decision = await activePlanner.replan({
-                        request,
+                        request: taskRequest,
                         plan,
                         currentStep,
                         remainingSteps: queue,
@@ -1151,6 +1426,7 @@ export class AgentRunEngine {
                         id: stepId,
                         index: stepCount,
                         route,
+                        ...(planned.askAnalystTaskId ? { askAnalystTaskId: planned.askAnalystTaskId } : {}),
                         goal: planned.goal,
                         successCriteria: planned.successCriteria,
                         status: "escalated",
@@ -1159,6 +1435,7 @@ export class AgentRunEngine {
                         evaluations,
                         artifacts: [],
                     });
+                    checkpointAuthoritativeTaskOutcomes();
                     emit({
                         type: "step.completed",
                         message: `Step ${stepCount} escalated to ${escalation.route.replaceAll("_", " ")}.`,
@@ -1173,11 +1450,12 @@ export class AgentRunEngine {
                     });
                     continue;
                 }
-                const outcome = computeStepOutcome(route, result, evaluations, request, isClarify, clarifyQuestion, routeDecision.terminalOutcome?.message);
+                const outcome = computeStepOutcome(route, result, evaluations, taskRequest, isClarify, clarifyQuestion, taskRouteDecision.terminalOutcome?.message);
                 const step = {
                     id: stepId,
                     index: stepCount,
                     route,
+                    ...(planned.askAnalystTaskId ? { askAnalystTaskId: planned.askAnalystTaskId } : {}),
                     resolvedRoute: result.resolvedRoute,
                     goal: planned.goal,
                     successCriteria: planned.successCriteria,
@@ -1197,6 +1475,11 @@ export class AgentRunEngine {
                         payload: artifact,
                     });
                 }
+                // Artifact events above are the immutable result proof. Checkpoint the
+                // task only after that proof has joined persisted progress; a restart
+                // between task siblings can then retain a completed independent result
+                // and mark only its dependents as blocked.
+                checkpointAuthoritativeTaskOutcomes();
                 emit({
                     type: "step.completed",
                     message: `Step ${stepCount} ${step.status}.`,
@@ -1210,7 +1493,14 @@ export class AgentRunEngine {
                     finalStep = step;
                     finalResult = result;
                     finalOutcome = outcome;
-                    break;
+                    // Every accepted authoritative child was frozen before the first
+                    // execution.  A blocked/clarify outcome for task-1 must not prevent
+                    // task-2 from receiving its independently scoped attempt and receipt.
+                    // Finalization below aggregates these outcomes as all-or-nothing, so
+                    // no partial answer can escape.
+                    if (!authoritativeCompoundAsk)
+                        break;
+                    continue;
                 }
                 finalStep = step;
                 finalResult = result;
@@ -1218,14 +1508,36 @@ export class AgentRunEngine {
                 if (outcome.status !== "blocked" && typeof result.answer === "string" && result.answer.trim().length > 0) {
                     bestAnswerResult = result;
                 }
-                if (outcome.status === "blocked")
+                if (outcome.status === "blocked" && !authoritativeCompoundAsk)
                     break;
-                if (outcome.status === "needs_clarification")
+                if (outcome.status === "needs_clarification" && !authoritativeCompoundAsk)
                     break;
-                if (isTerminalSuccess(route, outcome))
+                // A successful task is terminal only for a single-task Ask.  Multi-task
+                // authoritative plans were all frozen before execution and therefore
+                // continue to their own task-local result receipt.
+                const hasMoreAuthoritativeTasks = authoritativeAsk
+                    && (routeDecision.askAnalystDecision?.taskExecutions?.length ?? 0) > 1;
+                if (isTerminalSuccess(route, outcome) && !hasMoreAuthoritativeTasks)
                     break;
                 // Otherwise continue to the next planned step (if any remain).
             }
+            const authoritativeTaskOutcomeAggregate = authoritativePartialOutcomeMode
+                ? aggregateAuthoritativeTaskOutcomes({
+                    initialTaskOutcomes,
+                    taskExecutions: authoritativeTaskExecutions,
+                    steps: executedSteps,
+                    dependencyBlockedTaskIds: runtimeDependencyBlockedTaskIds,
+                    taskCount: initialTaskOutcomeSummary?.taskCount,
+                    finalized: true,
+                })
+                : undefined;
+            const authoritativeCompoundFailure = authoritativeCompoundAsk && !authoritativePartialOutcomeMode
+                ? compoundAskFailureForFrozenTasks({
+                    expectedTaskIds: [...authoritativeTaskIds],
+                    plan,
+                    steps: executedSteps,
+                })
+                : undefined;
             const run = this.finalizeRun({
                 runId,
                 request,
@@ -1239,6 +1551,8 @@ export class AgentRunEngine {
                 finalOutcome,
                 clarifyOutcome,
                 bestAnswerResult,
+                ...(authoritativeTaskOutcomeAggregate ? { authoritativeTaskOutcomeAggregate } : {}),
+                ...(authoritativeCompoundFailure ? { authoritativeCompoundFailure } : {}),
                 budgetUsage: cascadeBudgetTrace(budgets),
                 events,
             });
@@ -1259,7 +1573,8 @@ export class AgentRunEngine {
             run.diagnosticReceiptV2 = diagnosticReceiptV2ForRun(run);
             run.diagnosticReceiptV3 = diagnosticReceiptV3ForRun(run);
             run.diagnosticReceiptV4 = diagnosticReceiptV4ForRun(run);
-            run.artifacts = attachDiagnosticReceipt(run.artifacts, run.diagnosticReceipt, run.diagnosticReceiptV2, run.diagnosticReceiptV3, run.diagnosticReceiptV4);
+            attachAskAnalystRuntimeReceipt(run, request.askAgentRuntimeMode);
+            run.artifacts = attachDiagnosticReceipt(run.artifacts, run.diagnosticReceipt, run.diagnosticReceiptV2, run.diagnosticReceiptV3, run.diagnosticReceiptV4, run.diagnosticReceiptV5, run.diagnosticReceiptV6, run.diagnosticReceiptV7, run.diagnosticReceiptV8);
             finalizeAgentRunTraceV1(traceObserver, run);
             await checkpointQueue;
             await this.store?.save(run);
@@ -1349,6 +1664,7 @@ export class AgentRunEngine {
                 run.diagnosticReceiptV2 = diagnosticReceiptV2ForRun(run);
                 run.diagnosticReceiptV3 = diagnosticReceiptV3ForRun(run);
                 run.diagnosticReceiptV4 = diagnosticReceiptV4ForRun(run);
+                attachAskAnalystRuntimeReceipt(run, request.askAgentRuntimeMode);
                 finalizeAgentRunTraceV1(traceObserver, run);
                 await checkpointQueue;
                 await this.store?.save(run);
@@ -1438,7 +1754,8 @@ export class AgentRunEngine {
             run.diagnosticReceiptV2 = diagnosticReceiptV2ForRun(run);
             run.diagnosticReceiptV3 = diagnosticReceiptV3ForRun(run);
             run.diagnosticReceiptV4 = diagnosticReceiptV4ForRun(run);
-            run.artifacts = attachDiagnosticReceipt(retainedArtifacts, receipt, run.diagnosticReceiptV2, run.diagnosticReceiptV3, run.diagnosticReceiptV4);
+            attachAskAnalystRuntimeReceipt(run, request.askAgentRuntimeMode);
+            run.artifacts = attachDiagnosticReceipt(retainedArtifacts, receipt, run.diagnosticReceiptV2, run.diagnosticReceiptV3, run.diagnosticReceiptV4, run.diagnosticReceiptV5, run.diagnosticReceiptV6, run.diagnosticReceiptV7, run.diagnosticReceiptV8);
             finalizeAgentRunTraceV1(traceObserver, run);
             await checkpointQueue;
             await this.store?.save(run);
@@ -1450,6 +1767,113 @@ export class AgentRunEngine {
         const repairAttempts = input.budgetUsage.usage.laneExecutionAttemptsUsed;
         const escalationAttempts = input.budgetUsage.usage.engineEscalationsUsed;
         const completedAt = this.timestamp();
+        if (input.authoritativeTaskOutcomeAggregate) {
+            const aggregate = input.authoritativeTaskOutcomeAggregate;
+            const successfulSteps = input.steps.filter((step) => {
+                const taskId = step.askAnalystTaskId;
+                return taskId
+                    ? aggregate.summary.successfulTaskIds.includes(taskId)
+                    : false;
+            });
+            const lastSuccessfulStep = [...successfulSteps].reverse()[0];
+            const route = lastSuccessfulStep?.resolvedRoute ?? lastSuccessfulStep?.route ?? 'blocked';
+            const hasSuccessfulTask = aggregate.summary.successfulTaskIds.length > 0;
+            const status = !hasSuccessfulTask
+                ? 'blocked'
+                : aggregate.summary.trustState === 'review_required'
+                    ? 'needs_review'
+                    : 'completed';
+            const artifacts = input.steps.flatMap((step) => step.artifacts);
+            const evaluations = input.steps.flatMap((step) => step.evaluations);
+            const partialSummary = taskOutcomeAggregateSummaryText(aggregate.summary);
+            return {
+                id: input.runId,
+                question: input.request.question,
+                requestedMode: input.requestedMode,
+                conversationBinding: input.request.conversationBinding ?? traceConversationBinding(input.request, undefined),
+                route,
+                status,
+                trustState: aggregate.summary.trustState,
+                stopReason: status === 'blocked'
+                    ? 'blocked'
+                    : aggregate.summary.trustState === 'review_required'
+                        ? 'generated_review_required'
+                        : 'governed_compound_answer',
+                startedAt: input.startedAt,
+                completedAt,
+                selectedObject: input.request.selectedObject,
+                executionTarget: input.request.executionTarget,
+                routeDecision: input.routeDecision,
+                plan: input.plan,
+                steps: input.steps,
+                summary: partialSummary,
+                answer: partialSummary,
+                answerKind: 'governed',
+                artifacts,
+                evaluations,
+                events: input.events,
+                nextActions: applyAudienceToNextActions(defaultNextActions(route, status), resolveAudience(input.request), status),
+                repairAttempts,
+                escalationAttempts,
+                budgetUsage: input.budgetUsage,
+                analyticalTaskOutcomes: aggregate.outcomes,
+                analyticalTaskOutcomeSummary: aggregate.summary,
+                ...authoringDerivationFromRequest(input.request),
+            };
+        }
+        if (input.authoritativeCompoundFailure) {
+            const failure = input.authoritativeCompoundFailure;
+            const failedSteps = input.steps.filter((step) => step.askAnalystTaskId && failure.failedTaskIds.includes(step.askAnalystTaskId));
+            // The per-task steps remain on the run and trace as evidence, but a
+            // compound Ask never adopts an earlier data artifact/answer after one
+            // accepted frozen task failed.  Returning only the failed artifacts
+            // avoids presenting a partial result as the response to the whole ask.
+            const artifacts = failedSteps.flatMap((step) => step.artifacts);
+            const evaluations = [
+                ...input.steps.flatMap((step) => step.evaluations),
+                {
+                    id: 'authoritative-compound-all-or-nothing',
+                    label: 'Frozen Ask task completion',
+                    passed: false,
+                    severity: 'blocking',
+                    message: failure.message,
+                    evidence: {
+                        expectedTaskIds: failure.expectedTaskIds,
+                        completedTaskIds: failure.completedTaskIds,
+                        failedTaskIds: failure.failedTaskIds,
+                        missingTaskIds: failure.missingTaskIds,
+                    },
+                },
+            ];
+            return {
+                id: input.runId,
+                question: input.request.question,
+                requestedMode: input.requestedMode,
+                conversationBinding: input.request.conversationBinding ?? traceConversationBinding(input.request, undefined),
+                route: 'blocked',
+                status: 'blocked',
+                trustState: 'blocked',
+                stopReason: 'blocked',
+                startedAt: input.startedAt,
+                completedAt,
+                selectedObject: input.request.selectedObject,
+                executionTarget: input.request.executionTarget,
+                routeDecision: input.routeDecision,
+                plan: input.plan,
+                steps: input.steps,
+                summary: failure.message,
+                answer: failure.message,
+                answerKind: 'governed',
+                artifacts,
+                evaluations,
+                events: input.events,
+                nextActions: applyAudienceToNextActions(defaultNextActions('blocked', 'blocked'), resolveAudience(input.request), 'blocked'),
+                repairAttempts,
+                escalationAttempts,
+                budgetUsage: input.budgetUsage,
+                ...authoringDerivationFromRequest(input.request),
+            };
+        }
         if (!finalStep || !finalResult || !finalOutcome) {
             // No step produced a usable result (e.g. an empty plan). Treat as blocked.
             return {
@@ -1486,6 +1910,30 @@ export class AgentRunEngine {
             };
         }
         const route = finalResult.resolvedRoute ?? finalStep.resolvedRoute ?? finalStep.route;
+        // Provider diagnostics are produced at the physical runner boundary.
+        // Merge only that typed, redacted observation; executor prose never gets
+        // to rewrite routing, trust, or cascade authority.
+        // A V2 provider boundary can be observed by the tool runner after its
+        // legacy-shaped no-answer envelope has already crossed the local executor
+        // adapter.  The immutable V2 state is shared with this finalizer and is
+        // the durable source of truth at that point.  Project its terminal
+        // provider observation here, at the persisted route-decision boundary,
+        // rather than trying to infer it from user-facing error prose upstream.
+        const providerFailure = finalResult.providerFailure
+            // A frozen child receives the same server-owned V2 state as the root
+            // request.  Its scoped compiler decision deliberately replaces the
+            // business-plan fields, so use the request carrier as the first-class
+            // persistence fallback rather than losing a physical provider
+            // observation simply because the child route was rehydrated.
+            ?? providerFailureFromAskAgentV2State(input.request.askAgentV2State ?? input.routeDecision.askAgentV2Decision?.state)
+            // Planner/preflight failures can be terminal before a V2 executor emits
+            // an answer envelope.  The typed decision is already the authoritative
+            // boundary in that case; retain it for older receipt readers without
+            // classifying user-facing prose.
+            ?? input.routeDecision.providerFailure;
+        const finalRouteDecision = providerFailure
+            ? { ...input.routeDecision, providerFailure }
+            : input.routeDecision;
         // Aggregate artifacts across every accepted step so a multi-step plan
         // (e.g. research → block draft) surfaces all of its durable work, while the
         // status/trust/answer reflect the final step.
@@ -1512,7 +1960,7 @@ export class AgentRunEngine {
             completedAt,
             selectedObject: input.request.selectedObject,
             executionTarget: input.request.executionTarget,
-            routeDecision: input.routeDecision,
+            routeDecision: finalRouteDecision,
             plan: input.plan,
             steps: input.steps,
             summary: finalOutcome.summary,
@@ -1536,6 +1984,8 @@ export class AgentRunEngine {
             ...(finalResult.narrationIntegrityReceipt ? {
                 narrationIntegrityReceipt: finalResult.narrationIntegrityReceipt,
             } : {}),
+            ...(finalResult.askAnalystState ? { askAnalystState: finalResult.askAnalystState } : {}),
+            ...(finalResult.businessAnswer ? { businessAnswer: finalResult.businessAnswer } : {}),
             escalationAttempts,
             budgetUsage: input.budgetUsage,
             ...(finalResult.analyticalTurnPlan ? { analyticalTurnPlan: finalResult.analyticalTurnPlan } : {}),
@@ -1591,6 +2041,247 @@ export class AgentRunEngine {
         return this.now().toISOString();
     }
 }
+function canonicalTaskResultArtifactForStep(step) {
+    if (!step)
+        return undefined;
+    for (const artifact of step.artifacts) {
+        if (artifact.kind !== 'answer' || artifact.trustState === 'blocked')
+            continue;
+        const payload = objectRecordForResultFacts(artifact.payload);
+        const result = objectRecordForResultFacts(payload?.result);
+        const fingerprint = stringForResultFacts(result?.resultFingerprint);
+        if (!result || !fingerprint)
+            continue;
+        const canonical = canonicalResultForFactProjection(result);
+        if (!canonical || canonical.columns.length === 0 || canonical.resultFingerprint !== fingerprint)
+            continue;
+        return { resultFingerprint: fingerprint };
+    }
+    return undefined;
+}
+function hasAcceptedAuthoritativeTaskResult(step) {
+    if (step?.status !== 'passed' && step?.status !== 'repaired' && step?.status !== 'needs_review')
+        return false;
+    // A generated/review-required response becomes an accepted independent task
+    // only once the immutable canonical result artifact is present.  Narrative
+    // text alone is not evidence that a query executed.
+    return Boolean(canonicalTaskResultArtifactForStep(step));
+}
+function aggregateAuthoritativeTaskOutcomes(input) {
+    const outcomeByTaskId = new Map();
+    for (const outcome of input.initialTaskOutcomes) {
+        // Each compiler task is authoritative exactly once. Preserve a planning
+        // gap/dependency receipt while permitting a matching executable task to
+        // replace only its own provisional status after it actually runs.
+        outcomeByTaskId.set(outcome.taskId, {
+            ...outcome,
+            ...(outcome.dependencyTaskIds ? { dependencyTaskIds: [...outcome.dependencyTaskIds] } : {}),
+        });
+    }
+    const orderedTaskIds = [
+        ...input.taskExecutions.map((task) => task.taskId),
+        ...input.initialTaskOutcomes.map((outcome) => outcome.taskId),
+    ].filter((taskId, index, all) => all.indexOf(taskId) === index);
+    for (const taskExecution of input.taskExecutions) {
+        const taskId = taskExecution.taskId;
+        const dependencyTaskIds = input.dependencyBlockedTaskIds.get(taskId);
+        if (dependencyTaskIds?.length) {
+            outcomeByTaskId.set(taskId, {
+                version: 1,
+                taskId,
+                status: 'dependency_blocked',
+                trustState: 'blocked',
+                summary: 'This task was not executed because a required task did not complete successfully.',
+                failure: {
+                    version: 1,
+                    code: 'DEPENDENCY_BLOCKED',
+                    message: 'A prerequisite task did not complete successfully.',
+                    phase: 'dependency',
+                },
+                dependencyTaskIds: [...dependencyTaskIds],
+            });
+            continue;
+        }
+        const step = input.steps.find((candidate) => candidate.askAnalystTaskId === taskId);
+        if (!step) {
+            if (!input.finalized)
+                continue;
+            outcomeByTaskId.set(taskId, {
+                version: 1,
+                taskId,
+                status: 'blocked',
+                trustState: 'blocked',
+                summary: 'This task did not receive its required frozen execution attempt.',
+                failure: {
+                    version: 1,
+                    code: 'TASK_EXECUTION_MISSING',
+                    message: 'This task did not receive its required frozen execution attempt.',
+                    phase: 'execution',
+                },
+            });
+            continue;
+        }
+        if (hasAcceptedAuthoritativeTaskResult(step)) {
+            const trustState = taskOutcomeTrustForExecutedStep(step, taskExecution);
+            const resultFingerprint = taskResultFingerprintForStep(step);
+            outcomeByTaskId.set(taskId, {
+                version: 1,
+                taskId,
+                status: 'completed',
+                trustState,
+                summary: step.summary,
+                ...(resultFingerprint ? { resultFingerprint } : {}),
+            });
+            continue;
+        }
+        const isClarification = step.status === 'clarify';
+        const acceptedWithoutCanonicalResult = step.status === 'passed'
+            || step.status === 'repaired'
+            || step.status === 'needs_review';
+        const message = acceptedWithoutCanonicalResult
+            ? 'This task did not produce an immutable canonical result artifact.'
+            : step.summary ?? (isClarification
+                ? 'This task requires a business clarification before it can run.'
+                : 'This task did not complete its frozen execution.');
+        outcomeByTaskId.set(taskId, {
+            version: 1,
+            taskId,
+            status: isClarification ? 'gap' : 'blocked',
+            trustState: 'blocked',
+            summary: message,
+            failure: {
+                version: 1,
+                code: acceptedWithoutCanonicalResult
+                    ? 'TASK_EXECUTION_RESULT_MISSING'
+                    : isClarification ? 'TASK_REQUIRES_CLARIFICATION' : 'TASK_EXECUTION_FAILED',
+                message,
+                phase: 'execution',
+            },
+        });
+    }
+    const outcomes = orderedTaskIds
+        .map((taskId) => outcomeByTaskId.get(taskId))
+        .filter((outcome) => Boolean(outcome));
+    const successfulTaskIds = outcomes
+        .filter((outcome) => outcome.status === 'completed' || outcome.status === 'partial')
+        .map((outcome) => outcome.taskId);
+    const failedTaskIds = outcomes
+        .filter((outcome) => outcome.status !== 'completed' && outcome.status !== 'partial' && outcome.status !== 'dependency_blocked')
+        .map((outcome) => outcome.taskId);
+    const dependencyBlockedTaskIds = outcomes
+        .filter((outcome) => outcome.status === 'dependency_blocked')
+        .map((outcome) => outcome.taskId);
+    const successfulTrustStates = outcomes
+        .filter((outcome) => outcome.status === 'completed' || outcome.status === 'partial')
+        .map((outcome) => outcome.trustState ?? 'blocked');
+    const taskCount = Math.max(input.taskCount ?? 0, outcomes.length);
+    return {
+        outcomes,
+        summary: {
+            version: 1,
+            status: successfulTaskIds.length === 0
+                ? 'blocked'
+                : failedTaskIds.length || dependencyBlockedTaskIds.length || successfulTaskIds.length < taskCount
+                    ? 'partial'
+                    : 'completed',
+            trustState: leastTrustedExecutedTaskOutcomeState(successfulTrustStates),
+            taskCount,
+            successfulTaskIds,
+            failedTaskIds,
+            dependencyBlockedTaskIds,
+        },
+    };
+}
+function taskOutcomeTrustForExecutedStep(step, taskExecution) {
+    const artifactStates = step.artifacts
+        .map((artifact) => normalizeTaskOutcomeTrustState(artifact.trustState))
+        .filter((state) => Boolean(state));
+    const compiledState = taskExecution.compiledTrustState
+        ?? taskOutcomeTrustStateForCompiler(taskExecution.resolvedPlan.compiler);
+    // A review-required compiler is never elevated merely because an adapter
+    // artifact used the older `governed` label.
+    if (step.status === 'needs_review' || compiledState === 'review_required')
+        return 'review_required';
+    return leastTrustedExecutedTaskOutcomeState([...artifactStates, compiledState]);
+}
+function normalizeTaskOutcomeTrustState(trustState) {
+    if (trustState === 'grounded')
+        return 'governed';
+    return trustState === 'certified'
+        || trustState === 'governed'
+        || trustState === 'review_required'
+        || trustState === 'blocked'
+        || trustState === 'not_applicable'
+        ? trustState
+        : undefined;
+}
+function taskOutcomeTrustStateForCompiler(compiler) {
+    if (compiler === 'certified')
+        return 'certified';
+    if (compiler === 'metricflow' || compiler === 'governed_relational')
+        return 'governed';
+    if (compiler === 'exploratory_sql')
+        return 'review_required';
+    return 'blocked';
+}
+function leastTrustedExecutedTaskOutcomeState(states) {
+    if (states.length === 0)
+        return 'blocked';
+    const score = {
+        certified: 4,
+        governed: 3,
+        review_required: 2,
+        not_applicable: 1,
+        blocked: 0,
+    };
+    return states.reduce((least, candidate) => score[candidate] < score[least] ? candidate : least);
+}
+function taskResultFingerprintForStep(step) {
+    return canonicalTaskResultArtifactForStep(step)?.resultFingerprint;
+}
+function taskOutcomeAggregateSummaryText(summary) {
+    if (summary.status === 'completed') {
+        return `All ${summary.taskCount} independent analytical task${summary.taskCount === 1 ? '' : 's'} completed.`;
+    }
+    if (summary.status === 'partial') {
+        return `${summary.successfulTaskIds.length} of ${summary.taskCount} independent analytical task${summary.taskCount === 1 ? '' : 's'} completed. The remaining task receipts explain what needs attention.`;
+    }
+    return 'No independently executable analytical task completed. Review the task receipts for the recorded gaps or dependency blocks.';
+}
+/**
+ * A compound authoritative Ask is accepted only after every task has its own
+ * immutable program.  Preserve a receipt for every attempted child, then make
+ * the parent terminal when any child blocked/clarified/escalated or was never
+ * attempted.  This is intentionally evaluated after the queue drains so a
+ * first failure cannot hide a later frozen task from the trace.
+ */
+function compoundAskFailureForFrozenTasks(input) {
+    const expectedTaskIds = [...input.expectedTaskIds];
+    const expected = new Set(expectedTaskIds);
+    const taskSteps = input.steps.filter((step) => step.askAnalystTaskId && expected.has(step.askAnalystTaskId));
+    const completedTaskIds = [...new Set(taskSteps
+            .filter((step) => step.status === 'passed' || step.status === 'repaired' || step.status === 'needs_review')
+            .map((step) => step.askAnalystTaskId))];
+    const failedTaskIds = [...new Set(taskSteps
+            .filter((step) => step.status === 'blocked' || step.status === 'clarify' || step.status === 'escalated')
+            .map((step) => step.askAnalystTaskId))];
+    const attempted = new Set(taskSteps.map((step) => step.askAnalystTaskId));
+    const missingTaskIds = expectedTaskIds.filter((taskId) => !attempted.has(taskId));
+    if (failedTaskIds.length === 0 && missingTaskIds.length === 0 && completedTaskIds.length === expectedTaskIds.length) {
+        return undefined;
+    }
+    const failureParts = [
+        failedTaskIds.length ? `${failedTaskIds.length} frozen task${failedTaskIds.length === 1 ? '' : 's'} failed` : '',
+        missingTaskIds.length ? `${missingTaskIds.length} frozen task${missingTaskIds.length === 1 ? '' : 's'} did not receive an execution attempt` : '',
+    ].filter(Boolean);
+    return {
+        expectedTaskIds,
+        completedTaskIds,
+        failedTaskIds,
+        missingTaskIds,
+        message: `The Ask plan ran every available frozen task, but ${failureParts.join(' and ') || 'the task receipts were incomplete'}. No partial result was accepted.`,
+    };
+}
 function traceLinkFingerprint(value) {
     return `sha256:${createHash('sha256').update(value).digest('hex')}`;
 }
@@ -1975,6 +2666,26 @@ function clarificationAlreadyAsked(clarifyingQuestion, history) {
     return lastAsk > 0;
 }
 function enforceOrdinaryAnalyticalPlanBoundary(request, decision) {
+    // V2 deliberately has no deterministic business-meaning terminal at this
+    // seam.  Its candidate workspace is a bounded agent input, and pre-freeze
+    // ineligible/unavailable/ambiguous outcomes are returned to that same tool
+    // loop.  Do not let V1's rescue/reinterpretation policy create a second
+    // authority before the tool runtime can try the next safe tier.
+    if (decision.askAgentV2Decision?.mode === 'authoritative_v2'
+        || request.askAgentRuntimeMode === 'authoritative_v2') {
+        return decision;
+    }
+    // AskAnalystRuntimeV1 has already retrieved, planned, verified and (when
+    // possible) frozen this ordinary Ask turn.  The engine is a dispatcher at
+    // this boundary, not a second cascade owner.  In particular, do not let the
+    // legacy modelling-gap rescue reinterpret a pre-freeze canonical decision:
+    // that used to turn one immutable cascade into two competing routes.
+    // Post-freeze executor/warehouse safety checks remain below the engine
+    // boundary and are intentionally unchanged.
+    if (decision.askAnalystDecision?.mode === 'authoritative'
+        || request.askAnalystState?.mode === 'authoritative') {
+        return decision;
+    }
     const ordinaryAsk = request.requestedMode === undefined
         || request.requestedMode === 'auto'
         || request.requestedMode === 'ask';
@@ -2398,14 +3109,15 @@ function diagnosticReceiptV3ForRun(run) {
         .map((payload) => payload.providerFailure)
         .find((failure) => Boolean(failure) && typeof failure === 'object' && !Array.isArray(failure));
     const persistedProviderDiagnostic = artifactProviderDiagnostic?.diagnostic;
-    const provider = persistedProviderDiagnostic && typeof persistedProviderDiagnostic === 'object'
-        ? persistedProviderDiagnostic
-        : (() => {
-            const failure = run.diagnosticReceipt?.failure;
-            return failure && (failure.code === 'AI_PROVIDER_FAILURE' || /provider/i.test(failure.code))
-                ? classifyProviderFailure({ message: failure.message, code: failure.code, phase: 'generation' })
-                : undefined;
-        })();
+    const provider = run.routeDecision?.providerFailure
+        ?? (persistedProviderDiagnostic && typeof persistedProviderDiagnostic === 'object'
+            ? persistedProviderDiagnostic
+            : (() => {
+                const failure = run.diagnosticReceipt?.failure;
+                return failure && (failure.code === 'AI_PROVIDER_FAILURE' || /provider/i.test(failure.code))
+                    ? classifyProviderFailure({ message: failure.message, code: failure.code, phase: 'generation' })
+                    : undefined;
+            })());
     return {
         version: 3,
         runId: run.id,
@@ -2436,6 +3148,8 @@ function diagnosticReceiptV4ForRun(run) {
         roleCounts.set(evidence.role, (roleCounts.get(evidence.role) ?? 0) + evidence.candidateCount);
     }
     const terminalIncident = terminalIncidentForRun(run, cascade?.stopReason);
+    const runtimeReviewRequired = run.askAnalystState?.resolvedPlan?.reviewRequired === true
+        || run.routeDecision?.askAnalystDecision?.state.resolvedPlan?.reviewRequired === true;
     const summaryInput = {
         version: 1,
         understoodRequest: {
@@ -2464,7 +3178,7 @@ function diagnosticReceiptV4ForRun(run) {
                 selectedPlan: {
                     tier: cascade.selectedTier,
                     planFrozen: cascade.planFrozen,
-                    reviewRequired: cascade.selectedTier === 'exploratory_sql',
+                    reviewRequired: cascade.selectedTier === 'exploratory_sql' || runtimeReviewRequired,
                 },
             }
             : {}),
@@ -2487,6 +3201,1045 @@ function diagnosticReceiptV4ForRun(run) {
         finalStopReason: run.stopReason,
     };
 }
+/**
+ * Attach the V1.15 runtime state after the executor settles. The state was
+ * created before the compiler broker ran; this final projection adds only
+ * outcome counters and never asks a legacy layer to reinterpret the question.
+ */
+function attachAskAnalystRuntimeReceipt(run, runtimeMode) {
+    if (runtimeMode)
+        run.askAgentRuntimeMode = runtimeMode;
+    const initial = run.askAnalystState ?? run.routeDecision?.askAnalystDecision?.state;
+    if (!initial) {
+        attachAskAgentV2RuntimeReceipt(run);
+        return;
+    }
+    const phase = run.status === 'needs_clarification'
+        ? 'clarify'
+        : run.status === 'blocked' || run.status === 'cancelled'
+            ? 'blocked'
+            : 'executed';
+    const executionAttempts = analyticalExecutionAttemptCount(run);
+    const workspaceTools = runtimeWorkspaceToolsForRun(initial, run, executionAttempts);
+    const state = finalizeAskAnalystState(initial, {
+        phase,
+        workspaceTools,
+        ...(run.routeDecision?.askAnalystDecision?.resolvedPlan
+            ? { resolvedPlan: run.routeDecision.askAnalystDecision.resolvedPlan }
+            : {}),
+        toolCalls: workspaceTools.length,
+        executionAttempts,
+        repairAttempts: run.repairAttempts,
+    });
+    run.askAnalystState = state;
+    // Ordinary Ask intentionally does not send result rows to a narration
+    // provider.  Every successful compiler still owes the reader a useful,
+    // fact-bound answer, though.  Project the canonical local result into a
+    // bounded set of deterministic facts before accepting the BusinessAnswer;
+    // this is the common path for certified blocks, MetricFlow, and safe
+    // physical execution that did not already produce graph-native facts.
+    attachDeterministicResultFacts(run);
+    // The persisted/runtime envelope is the only reader-facing answer authority
+    // for an authoritative Ask.  Never let an executor's arbitrary `answer`
+    // bypass the fact/narrative validation below after the runtime has frozen a
+    // program.
+    run.businessAnswer = businessAnswerForRun(run);
+    run.answer = run.businessAnswer.answer;
+    run.diagnosticReceiptV5 = diagnosticReceiptV5ForRun(run, state, run.businessAnswer);
+    run.diagnosticReceiptV6 = diagnosticReceiptV6ForRun(run, state, run.diagnosticReceiptV5);
+    run.diagnosticReceiptV7 = diagnosticReceiptV7ForRun(run, state, run.diagnosticReceiptV6);
+}
+/** V2's compact receipt is additive and deliberately does not alter V1-V7. */
+function attachAskAgentV2RuntimeReceipt(run) {
+    const state = run.routeDecision?.askAgentV2Decision?.state;
+    if (!state)
+        return;
+    run.askAgentRuntimeMode ??= state.mode;
+    // The V2 tool runtime may already have recorded the exact terminal boundary
+    // (for example provider versus execution failure).  Do not overwrite it
+    // with the engine's broad status during persistence.
+    if (!state.terminalOutcome) {
+        state.terminal = run.status === 'needs_clarification'
+            ? 'clarification'
+            : run.status === 'blocked' || run.status === 'cancelled'
+                ? 'error'
+                : 'completed';
+    }
+    // V8 reports only V2 tool/execution evidence.  A route step or an inspected
+    // candidate is not a warehouse connection, and a failed validation is not a
+    // result.  Deriving these fields from the actual canonical tool receipts
+    // keeps a terminal tool error blocked instead of making it look like a
+    // review-required generated result.
+    const executionTools = new Set([
+        'run_certified',
+        'compile_and_run_semantic',
+        'compile_and_run_dql',
+        'validate_and_run_sql',
+    ]);
+    const executionObservations = state.observations.filter((observation) => executionTools.has(observation.tool)
+        && (observation.outcome === 'executed' || observation.outcome === 'error')
+        && observation.origin === 'execution');
+    const executionAttempts = executionObservations.length;
+    const hasExecutedResult = executionObservations.some((observation) => observation.outcome === 'executed');
+    // V2 deliberately has no V1 `resolvedAnalyticalPlan`.  Once its immutable
+    // tool receipt proves a frozen execution result, project the same bounded
+    // deterministic facts used by the older authoritative runtime.  This is
+    // presentation only: it neither reroutes the question nor grants a new
+    // execution capability.
+    if (hasExecutedResult) {
+        attachDeterministicResultFacts(run);
+        run.businessAnswer = businessAnswerForRun(run);
+        run.answer = run.businessAnswer.answer;
+    }
+    // The V2 receipt has no row/prompt payload.  It may nevertheless state the
+    // count of accepted fact identities only after an actual result boundary.
+    const businessAnswer = run.businessAnswer ?? businessAnswerForRun(run);
+    run.diagnosticReceiptV8 = createAskToolKernelV2(state).diagnosticReceipt(run.stopReason, {
+        connectionAttempted: executionAttempts > 0,
+        executionAttempts,
+        factCount: hasExecutedResult ? businessAnswer.factIds.length : 0,
+        narration: hasExecutedResult && businessAnswer.mode === 'facts_only'
+            ? 'fact_bound'
+            : run.status === 'needs_clarification'
+                ? 'not_applicable'
+                : 'deterministic_fallback',
+    }, {
+        // These are physical egress receipts owned by the server wrapper. A
+        // provider planning observation alone never increments the user-visible
+        // dispatch count.
+        providerDispatches: run.providerEgressReceipts?.length ?? 0,
+        toolCalls: state.observations.filter((observation) => !observation.executionAuthorized).length,
+        executionAttempts,
+        repairs: state.observations.filter((observation) => observation.executionAuthorized && observation.samePlanRepair).length,
+    });
+}
+/** Preserve either persisted state version while adding executor-owned facts. */
+function finalizeAskAnalystState(initial, input) {
+    return {
+        ...initial,
+        phase: input.phase,
+        workspace: {
+            ...initial.workspace,
+            tools: input.workspaceTools,
+        },
+        ...(input.resolvedPlan ? { resolvedPlan: input.resolvedPlan } : {}),
+        toolCalls: input.toolCalls,
+        executionAttempts: input.executionAttempts,
+        repairAttempts: input.repairAttempts,
+    };
+}
+function analyticalExecutionAttemptCount(run) {
+    const executableRoutes = new Set([
+        'certified_answer', 'semantic_answer', 'generated_answer', 'research',
+    ]);
+    return run.steps
+        .filter((step) => executableRoutes.has(step.resolvedRoute ?? step.route))
+        .reduce((total, step) => total + step.attempts, 0);
+}
+/**
+ * Keep the default runtime story short and useful: snapshot, interpretation
+ * when a provider actually ran, compiler, execution, and the one permitted
+ * repair.  Detailed nested spans remain in Advanced trace instead of flooding
+ * the first diagnostic view with every retrieval lane.
+ */
+function runtimeWorkspaceToolsForRun(initial, run, executionAttempts) {
+    const tools = [...initial.workspace.tools];
+    const has = (kind) => tools.some((tool) => tool.kind === kind);
+    const candidateIds = initial.workspace.admittedCandidateIds.slice(0, 32);
+    // Provider meaning receipts are written by AskAnalystRuntimeV1 at the actual
+    // call boundary. Do not synthesize one from aggregate telemetry here.
+    if (executionAttempts > 0 && !has('execute')) {
+        tools.push({
+            version: 1,
+            id: 'tool:execute',
+            kind: 'execute',
+            status: run.status === 'blocked' || run.status === 'cancelled' ? 'failed' : 'completed',
+            candidateIds,
+            reasonCode: run.status === 'blocked' || run.status === 'cancelled' ? 'execution_failed' : 'execution_completed',
+        });
+    }
+    if (run.repairAttempts > 0 && !has('repair')) {
+        tools.push({
+            version: 1,
+            id: 'tool:repair',
+            kind: 'repair',
+            status: run.status === 'blocked' ? 'failed' : 'completed',
+            candidateIds,
+            reasonCode: run.status === 'blocked' ? 'repair_exhausted' : 'repair_completed',
+        });
+    }
+    return tools.slice(0, 12);
+}
+const RESULT_FACT_MAX_ROWS = 10;
+const RESULT_FACT_MAX_COLUMNS = 12;
+const RESULT_FACT_MAX_VALUE_CHARS = 1_024;
+const RESULT_FACT_NARRATIVE_ROWS = 5;
+/**
+ * Turn a successful canonical result into local, result-fingerprint-bound
+ * facts when a compiler did not emit the stricter analytical graph fact set.
+ * This never calls a provider and never trusts an executor's prose.  It is
+ * deliberately bounded by rows, columns, and scalar size so a result cannot
+ * turn an Ask receipt into an unbounded secondary data store.
+ */
+function attachDeterministicResultFacts(run) {
+    if (run.status !== 'completed' && run.status !== 'needs_review')
+        return;
+    // Do not let a prior SQL cell, a draft, or an unrelated answer artifact
+    // become reader-facing fact authority. A fact projection belongs only to the
+    // executed answer artifact from the final authoritative frozen plan.
+    const authoritative = authoritativeExecutedAnswerArtifactsForRun(run);
+    const authoritativeIds = new Set(authoritative.map(({ artifact }) => artifact.id));
+    if (authoritativeIds.size === 0)
+        return;
+    run.artifacts = run.artifacts.map((artifact) => {
+        if (!authoritativeIds.has(artifact.id))
+            return artifact;
+        const payload = objectRecordForResultFacts(artifact.payload);
+        if (!payload || payload.kind === 'no_answer' || hasFactLinkedNarrative(payload))
+            return artifact;
+        const projection = deterministicResultFactProjection({
+            artifactId: artifact.id,
+            trustState: artifact.trustState,
+            question: run.question,
+            result: payload.result,
+            answerTier: typeof payload.answerTier === 'string' ? payload.answerTier : undefined,
+        });
+        if (!projection)
+            return artifact;
+        return {
+            ...artifact,
+            payload: {
+                ...payload,
+                analyticalFacts: projection.factSet,
+                analyticalNarrative: projection.narrative,
+            },
+        };
+    });
+}
+/**
+ * Facts and narrative may only come from the final execution artifact selected
+ * by an authoritative frozen Ask plan. `run.artifacts` intentionally retains
+ * earlier durable work for inspection, so scanning it wholesale would let a
+ * stale SQL cell or previous answer supersede the result the engine actually
+ * accepted. Multiple final answer artifacts are acceptable only when they
+ * prove the same canonical result fingerprint; ambiguity fails closed.
+ */
+function authoritativeExecutedAnswerArtifactsForRun(run) {
+    // Notebook Ask submits ordinary analytical turns as `auto`; the runtime has
+    // already classified and frozen the authoritative Ask plan by this point.
+    // Treating only the legacy explicit `ask` mode as fact eligible discarded
+    // verified result facts after a successful query and produced the generic
+    // "no fact-linked narrative" message. Other modes remain closed here.
+    const runtimeFrozenAuthoritative = run.askAnalystState?.mode === 'authoritative'
+        && run.askAnalystState.resolvedPlan?.planFrozen === true;
+    const decisionFrozenAuthoritative = run.routeDecision?.resolvedAnalyticalPlan?.mode === 'authoritative'
+        && run.routeDecision.analyticalCascadeDecision?.planFrozen === true;
+    // V2 freezes its typed plan in the tool kernel rather than in V1's
+    // `resolvedAnalyticalPlan`.  It may project local facts only when the
+    // terminal state says `finish_answer` *and* a real execution observation
+    // exists; a provider/general answer cannot acquire governed facts merely by
+    // finishing a turn.
+    const v2State = run.routeDecision?.askAgentV2Decision?.state;
+    const runtimeFrozenAuthoritativeV2 = run.askAgentRuntimeMode === 'authoritative_v2'
+        && v2State?.resolvedPlan?.frozen === true
+        && v2State.terminalOutcome?.kind === 'finish_answer'
+        && v2State.observations.some((observation) => (observation.outcome === 'executed'
+            && observation.origin === 'execution'
+            && (observation.tool === 'run_certified'
+                || observation.tool === 'compile_and_run_semantic'
+                || observation.tool === 'compile_and_run_dql'
+                || observation.tool === 'validate_and_run_sql')));
+    if ((run.requestedMode !== 'ask' && run.requestedMode !== 'auto')
+        || run.status === 'blocked'
+        || run.status === 'cancelled'
+        || (!runtimeFrozenAuthoritative && !decisionFrozenAuthoritative && !runtimeFrozenAuthoritativeV2)) {
+        return [];
+    }
+    const finalStep = [...run.steps].reverse().find((step) => (step.resolvedRoute ?? step.route) === run.route
+        && step.status !== 'blocked'
+        && step.status !== 'clarify');
+    const finalAnswerIds = new Set(finalStep?.artifacts
+        .filter((artifact) => artifact.kind === 'answer' && artifact.trustState !== 'blocked')
+        .map((artifact) => artifact.id));
+    // A V2 host result can reach the engine through its terminal executor
+    // envelope after the step was created. Its aggregate artifacts retain the
+    // frozen result even when the step-local artifact list is empty. This
+    // fallback is deliberately limited to a frozen V2 terminal execution; the
+    // canonical fingerprint check below still rejects ambiguity.
+    const acceptedArtifactIds = runtimeFrozenAuthoritativeV2
+        ? new Set(run.artifacts
+            .filter((artifact) => artifact.kind === 'answer' && artifact.trustState !== 'blocked')
+            .map((artifact) => artifact.id))
+        : finalAnswerIds.size > 0
+            ? finalAnswerIds
+            : undefined;
+    if (!acceptedArtifactIds?.size)
+        return [];
+    const candidates = run.artifacts.flatMap((artifact) => {
+        if (!acceptedArtifactIds.has(artifact.id) || artifact.kind !== 'answer' || artifact.trustState === 'blocked')
+            return [];
+        const payload = objectRecordForResultFacts(artifact.payload);
+        const rawResult = payload && objectRecordForResultFacts(payload.result);
+        const canonical = rawResult ? canonicalResultForFactProjection(rawResult) : undefined;
+        if (!payload || !canonical)
+            return [];
+        return [{ artifact, payload, resultFingerprint: canonical.resultFingerprint }];
+    });
+    const resultFingerprints = new Set(candidates.map((candidate) => candidate.resultFingerprint));
+    return resultFingerprints.size === 1 ? candidates : [];
+}
+function deterministicResultFactProjection(input) {
+    const rawResult = objectRecordForResultFacts(input.result);
+    const canonical = rawResult ? canonicalResultForFactProjection(rawResult) : undefined;
+    if (!rawResult || !canonical)
+        return undefined;
+    const rawReceipt = objectRecordForResultFacts(rawResult.executionReceipt);
+    const receiptFingerprint = stringForResultFacts(rawReceipt?.resultFingerprint);
+    if (canonical.columns.length === 0)
+        return undefined;
+    const columns = canonical.columns.slice(0, RESULT_FACT_MAX_COLUMNS);
+    const rows = canonical.rows.slice(0, RESULT_FACT_MAX_ROWS).map((row) => Object.fromEntries(columns.flatMap((column) => {
+        const value = boundedResultFactValue(row[column]);
+        return value === undefined ? [] : [[column, value]];
+    })));
+    const provenance = {
+        artifactId: input.artifactId,
+        trustState: input.trustState,
+        ...(input.answerTier ?? canonical.answerTier ? { answerTier: input.answerTier ?? canonical.answerTier } : {}),
+        ...(receiptFingerprint ? { executionReceiptFingerprint: receiptFingerprint } : {}),
+    };
+    const scopeDetails = {
+        rowCount: canonical.rowCount,
+        returnedRowCount: canonical.rows.length,
+        columns,
+        ...(canonical.truncated ? { truncated: true } : {}),
+    };
+    // The applied window is host-computed at the execution boundary and rides
+    // on the result payload itself — never provider prose. Without it, a
+    // truthful zero-row window answer is indistinguishable from a failure.
+    const rawWindow = objectRecordForResultFacts(rawResult.appliedTimeWindow);
+    const appliedTimeWindow = rawWindow
+        && stringForResultFacts(rawWindow.expression)
+        && stringForResultFacts(rawWindow.startInclusive)
+        && stringForResultFacts(rawWindow.endExclusive)
+        ? {
+            expression: stringForResultFacts(rawWindow.expression),
+            startInclusive: stringForResultFacts(rawWindow.startInclusive),
+            endExclusive: stringForResultFacts(rawWindow.endExclusive),
+        }
+        : undefined;
+    const facts = [
+        {
+            factId: deterministicResultFactId(canonical.resultFingerprint, 'scope', scopeDetails),
+            kind: 'result_scope',
+            resultFingerprint: canonical.resultFingerprint,
+            details: scopeDetails,
+            provenance,
+        },
+        ...(appliedTimeWindow ? [{
+                factId: deterministicResultFactId(canonical.resultFingerprint, 'window', appliedTimeWindow),
+                kind: 'result_window',
+                resultFingerprint: canonical.resultFingerprint,
+                details: appliedTimeWindow,
+                provenance,
+            }] : []),
+        ...rows.map((values, rowIndex) => ({
+            factId: deterministicResultFactId(canonical.resultFingerprint, `row:${rowIndex}`, values),
+            kind: 'result_row',
+            resultFingerprint: canonical.resultFingerprint,
+            rowIndex,
+            values,
+            provenance,
+        })),
+    ];
+    const factSetPayload = {
+        version: 1,
+        resultFingerprint: canonical.resultFingerprint,
+        facts,
+    };
+    const factSet = {
+        ...factSetPayload,
+        factSetId: `result-facts:${deterministicResultHash(factSetPayload).slice(0, 24)}`,
+    };
+    const narrative = deterministicResultNarrative({
+        question: input.question,
+        factSet,
+        rowCount: canonical.rowCount,
+        returnedRowCount: canonical.rows.length,
+        truncated: canonical.truncated === true,
+        columns,
+    });
+    return { factSet, narrative };
+}
+function deterministicResultNarrative(input) {
+    const scope = input.factSet.facts[0];
+    const windowFact = input.factSet.facts.find((fact) => fact.kind === 'result_window');
+    const windowText = windowFact
+        ? `${String(windowFact.details?.expression)} (${String(windowFact.details?.startInclusive)} through ${String(windowFact.details?.endExclusive)}, end exclusive)`
+        : undefined;
+    const claims = [{
+            claimId: 'claim:result_scope',
+            factIds: [scope.factId],
+            text: `The query returned ${input.rowCount.toLocaleString()} row${input.rowCount === 1 ? '' : 's'} across ${input.columns.length.toLocaleString()} column${input.columns.length === 1 ? '' : 's'}${input.truncated ? '; the returned rows are truncated.' : '.'}`,
+        }];
+    if (windowFact && windowText && input.returnedRowCount > 0) {
+        claims.push({
+            claimId: 'claim:result_window',
+            factIds: [windowFact.factId],
+            text: `Rows are filtered to ${windowText}.`,
+        });
+    }
+    const rowFacts = input.factSet.facts
+        .filter((fact) => fact.kind === 'result_row' && fact.rowIndex !== undefined && Boolean(fact.values))
+        .slice(0, RESULT_FACT_NARRATIVE_ROWS);
+    const rankedQuestion = /\b(?:top|highest|most|least|lowest)\b/i.test(input.question);
+    for (const fact of rowFacts) {
+        const values = fact.values;
+        const labelColumn = input.columns.find((column) => /(?:customer|account|client|user|name)(?:_|$)/i.test(column) && values[column] != null)
+            ?? input.columns.find((column) => values[column] != null);
+        const label = labelColumn ? deterministicResultDisplayValue(values[labelColumn]) : undefined;
+        const details = input.columns
+            .filter((column) => column !== labelColumn && values[column] !== undefined)
+            .map((column) => `${humanizeResultColumn(column)}: ${deterministicResultDisplayValue(values[column])}`);
+        const text = label
+            ? `${rankedQuestion ? 'Returned result' : 'Result'} ${fact.rowIndex + 1}: ${label}${details.length > 0 ? ` — ${details.join('; ')}` : ''}.`
+            : `Returned result ${fact.rowIndex + 1}${details.length > 0 ? `: ${details.join('; ')}` : '.'}`;
+        claims.push({
+            claimId: `claim:result_row:${fact.rowIndex}`,
+            factIds: [fact.factId],
+            text,
+        });
+    }
+    if (rowFacts.length === 0 && input.returnedRowCount === 0) {
+        // A LIMIT truncates surplus rows; returning zero therefore proves the
+        // window itself matched nothing. Naming the exact dates turns "failure"
+        // into "true and actionable": the reader can see at once whether their
+        // data simply ends before the requested period.
+        claims.push({
+            claimId: 'claim:no_returned_rows',
+            factIds: windowFact ? [scope.factId, windowFact.factId] : [scope.factId],
+            text: windowFact && windowText
+                ? `The query returned no rows for the requested window ${windowText} — the governed source holds no matching rows in that period.`
+                : 'The query completed with zero returned rows.',
+        });
+    }
+    return {
+        version: 1,
+        factSetId: input.factSet.factSetId,
+        text: claims.map((claim) => claim.text).join(' '),
+        claims,
+    };
+}
+function hasFactLinkedNarrative(payload) {
+    const factSet = objectRecordForResultFacts(payload.analyticalFacts);
+    const narrative = objectRecordForResultFacts(payload.analyticalNarrative);
+    if (!factSet || !narrative || typeof factSet.factSetId !== 'string' || narrative.factSetId !== factSet.factSetId)
+        return false;
+    // Facts may only narrate the exact canonical result that the artifact
+    // persists. A graph-native fact set produced before a normalization or
+    // execution-receipt change is useful diagnostics, but it is not authority
+    // for the reader-facing answer.
+    const rawResult = objectRecordForResultFacts(payload.result);
+    const canonical = rawResult ? canonicalResultForFactProjection(rawResult) : undefined;
+    if (rawResult && (!canonical || factSet.resultFingerprint !== canonical.resultFingerprint))
+        return false;
+    const factIds = new Set(Array.isArray(factSet.facts)
+        ? factSet.facts.flatMap((fact) => {
+            const record = objectRecordForResultFacts(fact);
+            return typeof record?.factId === 'string' ? [record.factId] : [];
+        })
+        : []);
+    if (factIds.size === 0 || !Array.isArray(narrative.claims))
+        return false;
+    const claims = narrative.claims.flatMap((claim) => {
+        const record = objectRecordForResultFacts(claim);
+        const ids = Array.isArray(record?.factIds)
+            ? record.factIds.filter((id) => typeof id === 'string')
+            : [];
+        return ids.length > 0 ? [ids] : [];
+    });
+    return claims.length > 0 && claims.every((ids) => ids.every((id) => factIds.has(id)));
+}
+function canonicalResultForFactProjection(rawResult) {
+    const rawReceipt = objectRecordForResultFacts(rawResult.executionReceipt);
+    const suppliedFingerprint = stringForResultFacts(rawResult.resultFingerprint);
+    const receiptFingerprint = stringForResultFacts(rawReceipt?.resultFingerprint);
+    // The persisted result fingerprint identifies the exact rendered row set.
+    // A nested receipt can identify an earlier graph/adapter boundary instead,
+    // so retain it separately as provenance but never let it replace the reader
+    // result identity. The host has already admitted this internal result at the
+    // execution boundary; this projector never accepts public row input.
+    return normalizeCanonicalQueryResult({
+        columns: rawResult.columns,
+        rows: rawResult.rows,
+        rowCount: rawResult.rowCount,
+        executionTime: rawResult.executionTime,
+        resultFingerprint: suppliedFingerprint ?? receiptFingerprint,
+        executionReceipt: rawResult.executionReceipt,
+        trustState: rawResult.trustState,
+        answerTier: rawResult.answerTier,
+    });
+}
+function objectRecordForResultFacts(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringForResultFacts(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function boundedResultFactValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return typeof value === 'string' && value.length > RESULT_FACT_MAX_VALUE_CHARS ? undefined : value;
+    }
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : undefined;
+    if (typeof value === 'bigint')
+        return value.toString();
+    try {
+        const serialized = JSON.stringify(value);
+        return serialized && serialized.length <= RESULT_FACT_MAX_VALUE_CHARS ? serialized : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function deterministicResultFactId(resultFingerprint, kind, payload) {
+    return `result-fact:${deterministicResultHash({ resultFingerprint, kind, payload }).slice(0, 24)}`;
+}
+function deterministicResultHash(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function deterministicResultDisplayValue(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? String(value) : 'not-a-number';
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    return typeof value === 'undefined' ? 'undefined' : String(value);
+}
+function humanizeResultColumn(column) {
+    return column.replace(/[_-]+/g, ' ').replace(/\b\w/g, (character) => character.toUpperCase());
+}
+function businessAnswerForRun(run) {
+    // An accepted compound Ask is all-or-nothing. The engine deliberately
+    // continues through later frozen children after an earlier one fails so the
+    // trace has a receipt for each task; it must not then replace the aggregate
+    // terminal message with a generic connection incident or a later child
+    // result. The blocking evaluation is server-generated at finalization, not
+    // executor prose, so it is a safe deterministic answer authority here.
+    const compoundFailure = run.evaluations.find((evaluation) => evaluation.id === 'authoritative-compound-all-or-nothing'
+        && evaluation.severity === 'blocking'
+        && evaluation.passed === false
+        && typeof evaluation.message === 'string'
+        && evaluation.message.trim().length > 0);
+    if (compoundFailure) {
+        return {
+            version: 1,
+            mode: 'deterministic_fallback',
+            trustState: 'blocked',
+            factIds: [],
+            answer: compoundFailure.message,
+            limitations: ['No partial result was accepted because one or more frozen Ask tasks did not complete.'],
+        };
+    }
+    const authoritative = authoritativeExecutedAnswerArtifactsForRun(run);
+    const factIds = new Set();
+    const resultFingerprint = authoritative[0]?.resultFingerprint;
+    const factSetIds = new Set();
+    const narratives = [];
+    for (const { payload: record } of authoritative) {
+        const factSet = record.analyticalFacts;
+        if (factSet && typeof factSet === 'object' && !Array.isArray(factSet)) {
+            const factRecord = factSet;
+            if (factRecord.resultFingerprint !== resultFingerprint)
+                continue;
+            if (typeof factRecord.factSetId === 'string')
+                factSetIds.add(factRecord.factSetId);
+            if (Array.isArray(factRecord.facts)) {
+                for (const fact of factRecord.facts) {
+                    if (fact && typeof fact === 'object' && typeof fact.factId === 'string') {
+                        factIds.add(fact.factId);
+                    }
+                }
+            }
+        }
+        const narrative = record.analyticalNarrative;
+        if (narrative && typeof narrative === 'object' && !Array.isArray(narrative)) {
+            const narrativeRecord = narrative;
+            const text = typeof narrativeRecord.text === 'string' ? narrativeRecord.text.trim() : '';
+            const factSetId = typeof narrativeRecord.factSetId === 'string' ? narrativeRecord.factSetId : '';
+            const claims = Array.isArray(narrativeRecord.claims)
+                ? narrativeRecord.claims.flatMap((claim) => {
+                    if (!claim || typeof claim !== 'object' || Array.isArray(claim))
+                        return [];
+                    const claimRecord = claim;
+                    const ids = Array.isArray(claimRecord.factIds)
+                        ? claimRecord.factIds.filter((id) => typeof id === 'string')
+                        : [];
+                    return [{ factIds: ids }];
+                })
+                : [];
+            if (text && factSetId)
+                narratives.push({ text, factSetId, claims });
+        }
+    }
+    const acceptedNarrative = narratives.find((narrative) => factSetIds.has(narrative.factSetId)
+        && narrative.claims.length > 0
+        && narrative.claims.every((claim) => claim.factIds.length > 0 && claim.factIds.every((id) => factIds.has(id))));
+    const factsOnly = Boolean(acceptedNarrative);
+    const deterministicAnswer = run.status === 'blocked' || run.status === 'cancelled'
+        ? deterministicTerminalAnswerForRun(run)
+        : run.status === 'needs_clarification'
+            ? 'One business choice is required before DQL can run this question.'
+            : run.analyticalTaskOutcomeSummary?.status === 'partial'
+                ? taskOutcomeAggregateSummaryText(run.analyticalTaskOutcomeSummary)
+                : 'The query completed, but no fact-linked narrative was retained. Open the result to review the validated data.';
+    return {
+        version: 1,
+        mode: factsOnly ? 'facts_only' : 'deterministic_fallback',
+        trustState: run.trustState === 'grounded' ? 'governed' : run.trustState,
+        factIds: [...factIds].sort(),
+        ...(resultFingerprint ? { resultFingerprint } : {}),
+        ...(run.analyticalTaskOutcomeSummary ? { taskOutcomeSummary: run.analyticalTaskOutcomeSummary } : {}),
+        answer: acceptedNarrative?.text ?? deterministicAnswer,
+        limitations: run.status === 'blocked'
+            ? ['No executable result was accepted.']
+            : run.status === 'needs_clarification'
+                ? ['A materially different executable business meaning requires a choice.']
+                : run.analyticalTaskOutcomeSummary?.status === 'partial'
+                    ? ['One or more independent analytical tasks did not complete; inspect the retained task receipts.']
+                    : factsOnly
+                        ? []
+                        : ['Narrative is deterministic because no validated analytical fact set was retained.'],
+    };
+}
+/**
+ * A blocked Ask still needs a useful, content-safe explanation.  Derive this
+ * only from the typed terminal incident already persisted for the run: never
+ * surface a raw connector, provider, SQL, or model error through the answer
+ * field.  The trace retains the redacted diagnostic receipt for operators.
+ */
+/** Words that carry no business meaning when matching a question to a field. */
+const UNMODELED_STOP_WORDS = new Set([
+    'what', 'which', 'who', 'whom', 'whose', 'where', 'when', 'why', 'how', 'the', 'a', 'an',
+    'is', 'are', 'was', 'were', 'be', 'been', 'do', 'does', 'did', 'has', 'have', 'had',
+    'for', 'from', 'with', 'and', 'or', 'of', 'in', 'on', 'at', 'to', 'by', 'per', 'each',
+    'me', 'my', 'our', 'his', 'her', 'their', 'them', 'they', 'he', 'she', 'it', 'that', 'this',
+    'show', 'list', 'give', 'find', 'tell', 'belongs', 'belong', 'get', 'top', 'most', 'many',
+]);
+/** The identifier leaves the snapshot actually admitted, as plain labels. */
+function modeledFieldLabels(run) {
+    const state = run.askAnalystState ?? run.routeDecision?.askAnalystDecision?.state;
+    const ids = [
+        ...(state?.workspace?.workspaceCandidateIds ?? []),
+        ...(state?.workspace?.admittedCandidateIds ?? []),
+    ];
+    const labels = ids.map((id) => {
+        const leaf = id.split(':').pop() ?? id;
+        return (leaf.split('.').pop() ?? leaf).replace(/_/g, ' ').trim().toLowerCase();
+    }).filter((label) => label.length > 2);
+    return [...new Set(labels)];
+}
+/**
+ * Say what is missing, and what exists instead.
+ *
+ * "DQL could not prove one safe analytical path" is true and useless: it does
+ * not say which part of the question could not be served, so the reader cannot
+ * tell a modeling gap from a bug and has nothing to try next. When a term in
+ * the question matches nothing the snapshot admitted — asking for "region"
+ * where only locations are modeled — naming that term and the nearest governed
+ * fields turns a dead end into a next step.
+ */
+function unmodeledRequestAnswer(run) {
+    const question = typeof run.question === 'string' ? run.question : '';
+    if (!question.trim())
+        return undefined;
+    const labels = modeledFieldLabels(run);
+    if (labels.length === 0)
+        return undefined;
+    const haystack = labels.join(' ');
+    const unmodeled = question
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]+/g, ' ')
+        .split(/\s+/)
+        .filter((word) => word.length > 3 && !UNMODELED_STOP_WORDS.has(word))
+        // A term the admitted snapshot never mentions, in any field, anywhere.
+        .find((word) => !haystack.includes(word) && !haystack.includes(word.replace(/s$/, '')));
+    if (!unmodeled)
+        return undefined;
+    const alternatives = labels.filter((label) => !/^\d/.test(label)).slice(0, 5);
+    return `"${unmodeled}" is not modeled in this project, so no governed query can answer it.`
+        + (alternatives.length
+            ? ` The fields that are modeled here include ${alternatives.join(', ')}.`
+                + ' Ask again using one of those, or tell me which should stand in for'
+                + ` "${unmodeled}".`
+            : '');
+}
+function deterministicTerminalAnswerForRun(run) {
+    const incident = terminalIncidentForRun(run, run.routeDecision?.analyticalCascadeDecision?.stopReason);
+    switch (incident?.code) {
+        case 'CONNECTION_NOT_CONFIGURED':
+            return 'No database connection is configured yet. Add an approved connection, then retry this question.';
+        case 'PROVIDER_FAILURE':
+            return 'The AI provider could not complete this Ask step. Check provider readiness, then retry.';
+        case 'COMPILATION_FAILED':
+            return 'DQL selected a governed plan but could not compile it for the current target. Review the semantic target, then retry.';
+        case 'RESULT_CONTRACT_MISMATCH':
+            return 'The query ran, but its result did not match the frozen plan. Review the result contract and trace, then retry.';
+        case 'ANALYTICAL_COVERAGE_GAP':
+            return unmodeledRequestAnswer(run)
+                ?? 'DQL could not prove one safe analytical path from the current metadata snapshot. Review the available modeled fields, then retry.';
+        case 'ANALYTICAL_EXECUTION_FAILED':
+            return 'The selected governed query did not complete on the current connection. Review the connection and trace, then retry.';
+        case 'CANCELLED':
+            return 'This Ask run was cancelled before it completed.';
+        default:
+            return 'No executable data answer was accepted for this Ask run.';
+    }
+}
+function diagnosticReceiptV5ForRun(run, state, businessAnswer) {
+    const legacy = run.diagnosticReceiptV4?.summary;
+    const selectedCompiler = state.resolvedPlan?.compiler;
+    const ordinaryRoleInferenceAmbiguity = run.status === 'needs_clarification'
+        && (state.version === 2 || state.version === 3)
+        && state.planningReceipt?.verification?.reasonCode === 'ordinary_role_inference_ambiguous';
+    const whatHappened = run.status === 'blocked'
+        ? 'The Ask runtime did not complete an executable analytical answer.'
+        : run.status === 'needs_clarification'
+            ? ordinaryRoleInferenceAmbiguity
+                ? 'The Ask runtime paused because inferred candidate fields need one business choice.'
+                : 'The Ask runtime paused because validated executable meanings materially differ.'
+            : selectedCompiler
+                ? `The Ask runtime compiled one route-neutral program with the ${selectedCompiler} compiler.`
+                : 'The Ask runtime completed without selecting an analytical compiler.';
+    const why = run.status === 'blocked'
+        ? legacy?.terminalIncident
+            ? `The recorded terminal incident was ${legacy.terminalIncident.code}.`
+            : 'No safe executable compiler plan was accepted from the current evidence snapshot.'
+        : run.status === 'needs_clarification'
+            ? ordinaryRoleInferenceAmbiguity
+                ? 'The snapshot retained multiple safe inferred fields for one requested role, so DQL did not choose or execute a query.'
+                : 'The selected meanings would change the result, so DQL did not guess.'
+            : state.resolvedPlan?.reviewRequired
+                ? 'The selected plan required review before generated SQL execution.'
+                : 'The selected plan passed the current compiler and trust boundary.';
+    const impact = run.status === 'blocked'
+        ? 'No executable data answer was completed for this run.'
+        : run.status === 'needs_clarification'
+            ? 'The query is waiting for one business choice; no query was executed.'
+            : businessAnswer.mode === 'facts_only'
+                ? 'The displayed answer is bound to validated result facts.'
+                : 'The displayed answer uses the deterministic narration fallback.';
+    const summaryInput = {
+        version: 2,
+        runtimeMode: state.mode,
+        whatHappened,
+        why,
+        impact,
+        nextAction: legacy?.safeNextAction ?? 'none',
+        ...(selectedCompiler ? { selectedCompiler } : {}),
+        programTaskCount: state.program.taskIds.length,
+        admittedCandidateCount: state.workspace.admittedCandidateIds.length,
+        toolCallCount: state.toolCalls,
+        executionAttempts: state.executionAttempts,
+    };
+    const provider = providerFailureForRun(run);
+    return {
+        version: 5,
+        runId: run.id,
+        state: diagnosticAskAnalystState(state),
+        summary: {
+            ...summaryInput,
+            summaryFingerprint: receiptFingerprint(summaryInput),
+        },
+        businessAnswer: diagnosticBusinessAnswer(businessAnswer),
+        ...(provider ? { provider } : {}),
+        finalStopReason: run.stopReason,
+    };
+}
+/**
+ * V6 is the concise, receipt-only Ask story shown by default. It is built
+ * from already durable state at finalization, so it cannot create a second
+ * routing authority or infer a connection/SQL attempt before one occurred.
+ */
+function diagnosticReceiptV6ForRun(run, state, receipt) {
+    const tools = state.workspace.tools;
+    const tool = (kind) => tools.find((item) => item.kind === kind);
+    const planner = tool('provider_meaning');
+    const extension = tool('candidate_extension');
+    const cascade = run.routeDecision?.analyticalCascadeDecision;
+    const planFrozen = state.resolvedPlan?.planFrozen === true || cascade?.planFrozen === true;
+    const executionAttempts = state.executionAttempts;
+    const connectionAttempted = planFrozen && (executionAttempts > 0 || terminalConnectionSetupFailureForRun(run));
+    const persistedPlanning = state.version === 2 || state.version === 3 ? state.planningReceipt : undefined;
+    // A failed dispatch is still a planner call. Older persisted V2 state could
+    // be checkpointed before its receipt incremented, while the tool boundary
+    // was already durable. Prefer that boundary to avoid a V6/UI story which
+    // says "planner skipped" even though diagnostics show a provider attempt.
+    const plannerAttempted = planner?.status === 'completed' || planner?.status === 'failed';
+    const plannerCalls = Math.max(persistedPlanning?.plannerCalls ?? 0, plannerAttempted ? Math.max(1, state.planningContinuations) : 0);
+    const revisionCalls = persistedPlanning?.revisionCalls
+        ?? (extension?.status === 'completed' && plannerCalls > 1 ? 1 : 0);
+    const plannerMode = persistedPlanning?.mode ?? (plannerCalls === 0
+        ? (state.workspace.admittedCandidateIds.length ? 'deterministic_binding' : 'exact_fast_path')
+        : revisionCalls > 0 ? 'targeted_revision' : 'initial_planner');
+    // V2 workspace admission captures count-only business role coverage after
+    // exact pins, atomic relationship paths, and the 16-card cap. Prefer it to
+    // raw retrieval metadata: the latter answers "what was found", while this
+    // receipt must explain "what the planner could actually use". V1 remains
+    // readable through the legacy trace-metadata fallback.
+    const recordedRoleCoverage = state.workspace.version === 2
+        ? state.workspace.roleCoverage
+        : undefined;
+    const roleCounts = new Map();
+    for (const candidate of run.routeDecision?.retrievalEvidence?.candidateTraceMetadata ?? []) {
+        roleCounts.set(candidate.role, (roleCounts.get(candidate.role) ?? 0) + 1);
+    }
+    const roleCoverage = recordedRoleCoverage?.length
+        ? recordedRoleCoverage
+            .filter((entry) => Number.isFinite(entry.candidateCount) && entry.candidateCount >= 0)
+            .map((entry) => ({
+            role: entry.role,
+            candidateCount: entry.candidateCount,
+            ...(entry.state === 'alternatives' || entry.state === 'proven' ? { state: entry.state } : {}),
+        }))
+            .sort((left, right) => left.role.localeCompare(right.role))
+        : [...roleCounts.entries()]
+            .map(([role, candidateCount]) => ({ role, candidateCount }))
+            .sort((left, right) => left.role.localeCompare(right.role));
+    const terminalIncident = run.diagnosticReceiptV4?.terminalIncident;
+    const verification = persistedPlanning?.verification ?? (state.phase === 'blocked'
+        ? { version: 1, status: 'invalid', missingRoles: [], candidateIds: [], reasonCode: 'pre_freeze_verification_blocked' }
+        : state.phase === 'clarify'
+            ? { version: 1, status: 'ambiguous', missingRoles: [], candidateIds: [], reasonCode: 'validated_meaning_ambiguity' }
+            : { version: 1, status: 'valid', missingRoles: [], candidateIds: state.program.candidateIds.slice(0, 16), reasonCode: 'immutable_program_verified' });
+    const story = [
+        { stage: 'retrieval', status: tool('retrieve_snapshot')?.status === 'failed' ? 'unavailable' : 'completed', reasonCode: tool('retrieve_snapshot')?.reasonCode ?? 'snapshot_not_recorded' },
+        { stage: 'role_coverage', status: state.workspace.workspaceCandidateIds?.length || state.workspace.admittedCandidateIds.length ? 'completed' : 'unavailable', reasonCode: state.workspace.workspaceCandidateIds?.length ? 'bounded_workspace_qualified' : 'no_qualified_workspace' },
+        {
+            stage: 'planner',
+            status: planner?.status === 'failed' ? 'blocked' : plannerCalls > 0 ? 'completed' : 'skipped',
+            reasonCode: planner?.reasonCode ?? plannerMode,
+        },
+        { stage: 'verification', status: verification.status === 'valid' ? 'completed' : verification.status === 'ambiguous' ? 'blocked' : 'blocked', reasonCode: verification.reasonCode },
+        { stage: 'targeted_recovery', status: extension?.status === 'completed' ? 'completed' : 'skipped', reasonCode: extension?.reasonCode ?? 'not_required' },
+        { stage: 'cascade', status: cascade?.planFrozen ? 'completed' : state.phase === 'blocked' ? 'blocked' : 'unavailable', reasonCode: cascade?.stopReason ?? (state.phase === 'blocked' ? 'pre_freeze_blocked' : 'cascade_not_selected') },
+        { stage: 'freeze', status: planFrozen ? 'completed' : 'skipped', reasonCode: planFrozen ? 'immutable_plan_frozen' : 'no_plan_frozen' },
+        { stage: 'connection', status: connectionAttempted ? 'completed' : 'skipped', reasonCode: connectionAttempted ? 'connection_boundary_attempted_after_freeze' : 'connection_not_attempted' },
+        { stage: 'execution', status: executionAttempts > 0 ? 'completed' : 'skipped', reasonCode: executionAttempts > 0 ? 'executor_attempt_recorded' : 'execution_not_attempted' },
+        { stage: 'facts', status: receipt.businessAnswer?.factIds.length ? 'completed' : 'skipped', reasonCode: receipt.businessAnswer?.factIds.length ? 'fact_bound_business_answer' : 'no_accepted_result_facts' },
+    ];
+    return {
+        ...receipt,
+        version: 6,
+        planning: {
+            version: 1,
+            mode: plannerMode,
+            plannerCalls,
+            revisionCalls,
+            verification,
+        },
+        roleCoverage,
+        cascade: {
+            attempts: (cascade?.attempts ?? []).map((attempt) => ({
+                tier: attempt.tier,
+                outcome: attempt.outcome,
+                planFrozen: attempt.planFrozen,
+            })),
+            ...(cascade?.selectedTier ? { selectedTier: cascade.selectedTier } : {}),
+            ...(cascade?.stopReason ? { stopReason: cascade.stopReason } : {}),
+            planFrozen,
+        },
+        ...(terminalIncident ? {
+            origin: {
+                boundary: terminalIncident.boundary,
+                origin: terminalIncident.origin,
+                impact: terminalIncident.impact,
+            },
+        } : {}),
+        connection: { attempted: connectionAttempted },
+        execution: { attempts: executionAttempts },
+        facts: {
+            factCount: receipt.businessAnswer?.factIds.length ?? 0,
+            ...(receipt.businessAnswer?.resultFingerprint ? { resultFingerprint: receipt.businessAnswer.resultFingerprint } : {}),
+        },
+        safeNextAction: receipt.summary.nextAction,
+        story,
+    };
+}
+/**
+ * V7 is the compact first-read inspector. It is a pure projection of the
+ * finalized V6 receipt and frozen runtime state, so browser presentation
+ * cannot become a second planner, router, or trust authority.
+ */
+function diagnosticReceiptV7ForRun(run, state, receipt) {
+    const requirements = state.frame.requirements;
+    const planning = receipt.planning;
+    const resolvedPlan = state.resolvedPlan ?? run.routeDecision?.askAnalystDecision?.resolvedPlan;
+    const factCount = receipt.facts.factCount;
+    const narration = factCount > 0
+        ? 'fact_bound'
+        : run.status === 'completed' || run.status === 'needs_review'
+            ? 'result_without_facts'
+            : 'not_applicable';
+    return {
+        ...receipt,
+        version: 7,
+        inspector: {
+            understood: {
+                questionKind: state.frame.kind,
+                conversationBinding: state.frame.conversation.binding,
+                measureCount: requirements.measures.length,
+                dimensionCount: requirements.dimensions.length + requirements.entityDisplayTerms.length + (requirements.outputTerms?.length ?? 0),
+                entityRequested: requirements.entityTerms.length > 0,
+                hasBoundFilter: state.program.filters.length > 0,
+            },
+            evidence: {
+                admittedCandidateCount: state.workspace.admittedCandidateIds.length,
+                roleCount: receipt.roleCoverage.length,
+                recoveryAttempted: receipt.story.some((step) => step.stage === 'targeted_recovery' && step.status === 'completed'),
+            },
+            planning: {
+                mode: planning?.mode ?? 'deterministic_binding',
+                plannerCalls: planning?.plannerCalls ?? 0,
+                verification: planning?.verification.status ?? (state.phase === 'clarify' ? 'ambiguous' : state.phase === 'blocked' ? 'invalid' : 'valid'),
+            },
+            route: {
+                ...(receipt.cascade.selectedTier ? { selectedTier: receipt.cascade.selectedTier } : {}),
+                tierAttemptCount: receipt.cascade.attempts.length,
+                planFrozen: receipt.cascade.planFrozen,
+                reviewRequired: resolvedPlan?.reviewRequired === true,
+            },
+            outcome: {
+                connectionAttempted: receipt.connection.attempted,
+                executionAttempts: receipt.execution.attempts,
+                factCount,
+                narration,
+            },
+        },
+    };
+}
+function providerFailureForRun(run) {
+    if (run.routeDecision?.providerFailure)
+        return run.routeDecision.providerFailure;
+    if (run.diagnosticReceiptV3?.provider)
+        return run.diagnosticReceiptV3.provider;
+    for (const artifact of run.artifacts) {
+        const payload = artifact.payload;
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+            continue;
+        const failure = payload.providerFailure;
+        if (!failure || typeof failure !== 'object' || Array.isArray(failure))
+            continue;
+        const diagnostic = failure.diagnostic;
+        if (diagnostic && typeof diagnostic === 'object' && !Array.isArray(diagnostic)) {
+            return diagnostic;
+        }
+    }
+    return undefined;
+}
+/**
+ * Project the V2 tool-kernel's terminal provider observation for V1/V3
+ * receipt readers.  This runs only at the final persistence boundary, after
+ * the provider/tool runner has settled its shared state.  It intentionally
+ * does not classify free-form error text or synthesize a failure for a
+ * non-terminal provider observation.
+ */
+function providerFailureFromAskAgentV2State(state) {
+    if (state?.terminalOutcome?.kind !== 'provider_failure')
+        return undefined;
+    const provider = [...state.observations]
+        .reverse()
+        .find((observation) => observation.provider)?.provider;
+    if (!provider)
+        return undefined;
+    const phase = provider.phase === 'agent_control'
+        || provider.phase === 'tool_followup'
+        ? 'generation'
+        : provider.phase;
+    const safeAction = provider.safeAction === 'retry_same_provider'
+        || provider.safeAction === 'fix_provider_configuration'
+        || provider.safeAction === 'wait_and_retry'
+        || provider.safeAction === 'inspect_run'
+        || provider.safeAction === 'none'
+        ? provider.safeAction
+        : 'inspect_run';
+    return {
+        version: 1,
+        cause: provider.cause,
+        phase,
+        retryable: provider.retryable,
+        safeAction,
+    };
+}
+/** Content-free export boundary for V5 inspector/full-trace receipts. */
+function diagnosticAskAnalystState(state) {
+    return {
+        version: 1,
+        mode: state.mode,
+        phase: state.phase,
+        questionFingerprint: state.frame.questionFingerprint,
+        kind: state.frame.kind,
+        requirementCounts: {
+            measures: state.frame.requirements.measures.length,
+            dimensions: state.frame.requirements.dimensions.length,
+            entityTerms: state.frame.requirements.entityTerms.length + state.frame.requirements.entityDisplayTerms.length,
+            members: state.frame.requirements.memberTerms.length,
+            filters: state.program.filters?.length ?? 0,
+        },
+        mission: {
+            mode: state.mission.mode,
+            taskCount: state.mission.tasks.length,
+            deferredTaskCount: state.mission.deferredTasks?.length ?? 0,
+            hypothesisCount: state.mission.hypotheses.length,
+        },
+        workspace: {
+            ...(state.workspace.snapshotId ? { snapshotId: state.workspace.snapshotId } : {}),
+            ...(state.workspace.sourceFingerprint ? { sourceFingerprint: state.workspace.sourceFingerprint } : {}),
+            admittedCandidateCount: state.workspace.admittedCandidateIds.length,
+            excludedCandidateCount: state.workspace.excludedCandidates.length,
+            sourceCoverage: state.workspace.sourceCoverage.map((coverage) => ({
+                source: coverage.source,
+                status: coverage.status,
+                candidateCount: coverage.candidateIds.length,
+            })),
+            tools: state.workspace.tools.map((tool) => ({
+                id: tool.id,
+                kind: tool.kind,
+                status: tool.status,
+                reasonCode: tool.reasonCode,
+            })),
+        },
+        program: {
+            id: state.program.id,
+            taskCount: state.program.taskIds.length,
+            candidateCount: state.program.candidateIds.length,
+            requiredRoles: [...state.program.requiredRoles],
+            outputAssertionCount: state.program.outputs.assertions?.length ?? 0,
+        },
+        ...(state.resolvedPlan ? { resolvedPlan: state.resolvedPlan } : {}),
+        counters: {
+            planningContinuations: state.planningContinuations,
+            toolCalls: state.toolCalls,
+            executionAttempts: state.executionAttempts,
+            repairAttempts: state.repairAttempts,
+        },
+    };
+}
+function diagnosticBusinessAnswer(answer) {
+    return {
+        version: 1,
+        mode: answer.mode,
+        trustState: answer.trustState,
+        factIds: [...answer.factIds],
+        ...(answer.resultFingerprint ? { resultFingerprint: answer.resultFingerprint } : {}),
+        limitationCount: answer.limitations.length,
+    };
+}
 const ASK_SUMMARY_EVIDENCE_ROLES = [
     'metric',
     'entity_key',
@@ -2698,8 +4451,17 @@ function isAskResearchChildTier(value) {
     return Boolean(value) && ASK_RESEARCH_CHILD_TIERS.includes(value);
 }
 function terminalIncidentForRun(run, cascadeStopReason) {
+    const runtimeState = run.askAnalystState ?? run.routeDecision?.askAnalystDecision?.state;
+    const planFrozen = runtimeState?.resolvedPlan?.planFrozen === true
+        || run.routeDecision?.analyticalCascadeDecision?.planFrozen === true;
+    const executionRecorded = analyticalExecutionAttemptCount(run) > 0
+        || (run.telemetry?.sqlExecutions ?? 0) > 0;
     const executionSetupFailure = terminalConnectionSetupFailureForRun(run);
-    if (executionSetupFailure) {
+    // Connection wording is legal only after an immutable plan crossed its
+    // actual connector boundary. A planner/verification failure is never a
+    // "current connection" incident merely because an older adapter used a
+    // broad blocked status.
+    if (executionSetupFailure && planFrozen) {
         return {
             version: 1,
             code: 'CONNECTION_NOT_CONFIGURED',
@@ -2749,7 +4511,7 @@ function terminalIncidentForRun(run, cascadeStopReason) {
     if (failureCode === 'RUN_CANCELLED' || run.status === 'cancelled') {
         return { version: 1, code: 'CANCELLED', boundary: 'run', origin: 'unknown', impact: 'run_cancelled', safeAction: 'none' };
     }
-    if (failureCode === 'CONNECTION_NOT_CONFIGURED') {
+    if (failureCode === 'CONNECTION_NOT_CONFIGURED' && planFrozen) {
         return { version: 1, code: 'CONNECTION_NOT_CONFIGURED', boundary: 'sql.execute', origin: 'governance_gate', impact: 'execution_not_attempted', safeAction: 'configure_connection' };
     }
     // A frozen semantic/analytical plan may fail while the compiler is resolving
@@ -2769,6 +4531,21 @@ function terminalIncidentForRun(run, cascadeStopReason) {
             safeAction: compilationFailure.safeAction,
         };
     }
+    // Result validation is a distinct post-execution boundary. The statement
+    // may have run successfully, but its rows were deliberately rejected
+    // against the immutable plan; do not rewrite that evidence as a connection
+    // or SQL execution failure merely because both happen after plan freeze.
+    const resultValidationFailure = terminalResultValidationFailureForRun(run);
+    if (resultValidationFailure) {
+        return {
+            version: 1,
+            code: 'RESULT_CONTRACT_MISMATCH',
+            boundary: 'result.validate',
+            origin: 'result_validator',
+            impact: 'answer_not_produced',
+            safeAction: resultValidationFailure.safeAction,
+        };
+    }
     const warehouseFailure = terminalWarehouseFailureForRun(run);
     if (warehouseFailure) {
         return {
@@ -2791,9 +4568,28 @@ function terminalIncidentForRun(run, cascadeStopReason) {
     if (cascadeStopReason === 'coverage_gap' || cascadeStopReason === 'ambiguous' || cascadeStopReason === 'denied') {
         return { version: 1, code: 'ANALYTICAL_COVERAGE_GAP', boundary: 'cascade', origin: 'governance_gate', impact: 'answer_not_produced', safeAction: 'inspect_failure' };
     }
-    if (run.status === 'blocked') {
+    // Planning/meaning/reference validation has no connection or SQL boundary.
+    // Preserve that truth even when an older adapter gives the terminal run a
+    // broad `blocked` status without a cascade stop reason.
+    if (run.status === 'blocked'
+        && runtimeState?.phase === 'blocked'
+        && !planFrozen
+        && !executionRecorded) {
+        return {
+            version: 1,
+            code: 'ANALYTICAL_COVERAGE_GAP',
+            boundary: 'cascade',
+            origin: 'governance_gate',
+            impact: 'answer_not_produced',
+            safeAction: 'inspect_failure',
+        };
+    }
+    if (run.status === 'blocked' && planFrozen && executionRecorded) {
         return { version: 1, code: 'ANALYTICAL_EXECUTION_FAILED', boundary: 'sql.execute', origin: 'unknown', impact: 'execution_failed', safeAction: 'inspect_failure' };
     }
+    if (run.status === 'blocked') {
+        return { version: 1, code: 'ANALYTICAL_COVERAGE_GAP', boundary: 'cascade', origin: 'governance_gate', impact: 'answer_not_produced', safeAction: 'inspect_failure' };
+    }
     return undefined;
 }
 /**
@@ -2826,6 +4622,50 @@ function terminalConnectionSetupFailureForRun(run) {
 function terminalCompilationFailureForRun(run) {
     if ((run.telemetry?.sqlExecutions ?? 0) > 0)
         return undefined;
+    for (const artifact of run.artifacts) {
+        const payload = artifact.payload;
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+            continue;
+        const record = payload;
+        const failure = record.analyticalFailure;
+        if (failure && typeof failure === 'object' && !Array.isArray(failure)) {
+            const failureRecord = failure;
+            if (failureRecord.code === 'COMPILATION_FAILED' && failureRecord.phase === 'compilation') {
+                return {
+                    safeAction: terminalIncidentSafeAction(failureRecord.safeActions) ?? 'inspect_failure',
+                };
+            }
+        }
+        // Semantic adapters retain their own compiler receipt. Some historical
+        // answer-loop paths lose the outer analytical-failure wrapper while
+        // serializing a failed provider tool result; the typed semantic receipt is
+        // still a pre-SQL compiler fact and must never fall through to the generic
+        // "current connection" incident. It is only considered before a durable
+        // SQL execution counter exists, so a real warehouse failure keeps its
+        // execution classification.
+        const semanticTrace = record.semanticExecutionTrace;
+        if (!semanticTrace || typeof semanticTrace !== 'object' || Array.isArray(semanticTrace))
+            continue;
+        const traceFailure = semanticTrace.failure;
+        if (!traceFailure || typeof traceFailure !== 'object' || Array.isArray(traceFailure))
+            continue;
+        const traceFailureRecord = traceFailure;
+        if (traceFailureRecord.phase === 'compilation'
+            && (traceFailureRecord.code === 'SEMANTIC_COMPILATION_FAILED'
+                || traceFailureRecord.code === 'COMPILATION_FAILED')) {
+            return {
+                safeAction: terminalIncidentSafeAction(traceFailureRecord.safeActions) ?? 'inspect_failure',
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * A validated result-contract rejection is neither a compiler failure nor a
+ * warehouse failure. Read only the producer-owned typed failure so malformed
+ * or legacy error text cannot manufacture this incident.
+ */
+function terminalResultValidationFailureForRun(run) {
     for (const artifact of run.artifacts) {
         const payload = artifact.payload;
         if (!payload || typeof payload !== 'object' || Array.isArray(payload))
@@ -2833,11 +4673,11 @@ function terminalCompilationFailureForRun(run) {
         const failure = payload.analyticalFailure;
         if (!failure || typeof failure !== 'object' || Array.isArray(failure))
             continue;
-        const record = failure;
-        if (record.code !== 'COMPILATION_FAILED' || record.phase !== 'compilation')
+        const failureRecord = failure;
+        if (failureRecord.code !== 'RESULT_CONTRACT_MISMATCH' || failureRecord.phase !== 'result_validation')
             continue;
         return {
-            safeAction: terminalIncidentSafeAction(record.safeActions) ?? 'inspect_failure',
+            safeAction: terminalIncidentSafeAction(failureRecord.safeActions) ?? 'inspect_failure',
         };
     }
     return undefined;
@@ -2943,7 +4783,7 @@ function durationBetweenMs(startedAt, completedAt) {
 function receiptFingerprint(value) {
     return createHash('sha256').update(JSON.stringify(value)).digest('hex');
 }
-function attachDiagnosticReceipt(artifacts, receipt, receiptV2, receiptV3, receiptV4) {
+function attachDiagnosticReceipt(artifacts, receipt, receiptV2, receiptV3, receiptV4, receiptV5, receiptV6, receiptV7, receiptV8) {
     if (artifacts.length === 0) {
         if (!receipt.failure)
             return artifacts;
@@ -2952,7 +4792,7 @@ function attachDiagnosticReceipt(artifacts, receipt, receiptV2, receiptV3, recei
                 kind: "answer",
                 title: "Agent run diagnostics",
                 trustState: "blocked",
-                payload: { diagnosticReceipt: receipt, ...(receiptV2 ? { diagnosticReceiptV2: receiptV2 } : {}), ...(receiptV3 ? { diagnosticReceiptV3: receiptV3 } : {}), ...(receiptV4 ? { diagnosticReceiptV4: receiptV4 } : {}) },
+                payload: { diagnosticReceipt: receipt, ...(receiptV2 ? { diagnosticReceiptV2: receiptV2 } : {}), ...(receiptV3 ? { diagnosticReceiptV3: receiptV3 } : {}), ...(receiptV4 ? { diagnosticReceiptV4: receiptV4 } : {}), ...(receiptV5 ? { diagnosticReceiptV5: receiptV5 } : {}), ...(receiptV6 ? { diagnosticReceiptV6: receiptV6 } : {}), ...(receiptV7 ? { diagnosticReceiptV7: receiptV7 } : {}), ...(receiptV8 ? { diagnosticReceiptV8: receiptV8 } : {}) },
             }];
     }
     const preferredIndex = Math.max(0, artifacts.findIndex((artifact) => artifact.kind === "answer"));
@@ -2970,10 +4810,72 @@ function attachDiagnosticReceipt(artifacts, receipt, receiptV2, receiptV3, recei
                 ...(receiptV2 ? { diagnosticReceiptV2: receiptV2 } : {}),
                 ...(receiptV3 ? { diagnosticReceiptV3: receiptV3 } : {}),
                 ...(receiptV4 ? { diagnosticReceiptV4: receiptV4 } : {}),
+                ...(receiptV5 ? { diagnosticReceiptV5: receiptV5 } : {}),
+                ...(receiptV6 ? { diagnosticReceiptV6: receiptV6 } : {}),
+                ...(receiptV7 ? { diagnosticReceiptV7: receiptV7 } : {}),
+                ...(receiptV8 ? { diagnosticReceiptV8: receiptV8 } : {}),
             },
         };
     });
 }
+function acceptedAskAgentV2TerminalState(request, decision, result, runId) {
+    // A scoped execution can retain an earlier immutable request snapshot while
+    // the provider advances its cloned V2 state. That is why the execution
+    // carrier is an explicit runner return value. It is *not* enough for an
+    // executor to return receipt-shaped JSON: the engine verifies the
+    // process-local server attestation, current run, immutable snapshot closure,
+    // frozen plan identity, and canonical result fingerprint below.
+    const states = [
+        request.askAgentV2State,
+        decision.askAgentV2Decision?.state,
+    ].filter((state) => Boolean(state));
+    if (result.status === 'blocked')
+        return undefined;
+    const receipt = result.askAgentV2ExecutionReceipt;
+    const terminal = result.askAgentV2Outcome;
+    const state = states.find((candidate) => isAskV2ExecutionReceiptAuthorizedV1({
+        receipt,
+        capability: request.askAgentV2ExecutionCapability,
+        state: candidate,
+        result: result.result,
+        runId,
+    }));
+    if (state
+        && receipt
+        && terminal?.kind === 'finish_answer'
+        && terminal.origin === 'execution') {
+        return { tier: receipt.tier, planId: receipt.planId };
+    }
+    return undefined;
+}
+/**
+ * Keep a gate's VERDICT while removing its authority to re-plan.
+ *
+ * After an accepted V2 terminal, the frozen plan already executed; the legacy
+ * repair machinery would replan the same artifact, be refused as
+ * POST_FREEZE_REPAIR_REQUIRED, and discard the validated result. The failure
+ * itself must still be visible — that is the entire point of running the
+ * gates — so only the repair hooks are stripped.
+ */
+function disarmRepairForV2Terminal(evaluation) {
+    if (evaluation.passed)
+        return evaluation;
+    const { suggestedRepair: _repair, repairAction: _action, ...reported } = evaluation;
+    return reported;
+}
+function acceptedAskAgentV2TerminalEvaluation(boundary) {
+    return {
+        id: 'ask-v2-terminal-result',
+        label: 'Authoritative V2 result validation',
+        passed: true,
+        severity: 'info',
+        message: 'The snapshot-bound V2 plan executed and its result was validated before the terminal answer was accepted.',
+        evidence: {
+            tier: boundary.tier,
+            planId: boundary.planId,
+        },
+    };
+}
 function computeStepOutcome(route, result, evaluations, request, isClarify, clarifyQuestion, terminalOutcomeMessage) {
     const fallback = defaultOutcome(route);
     if (isClarify) {
@@ -2985,16 +4887,32 @@ function computeStepOutcome(route, result, evaluations, request, isClarify, clar
             summary: result.summary ?? clarifyQuestion ?? fallback.summary,
         };
     }
-    const status = result.status ?? statusFromEvaluations(route, evaluations, fallback.status);
-    const trustState = result.trustState ?? trustStateFromEvaluations(route, evaluations, fallback.trustState);
+    const rawStatus = result.status ?? statusFromEvaluations(route, evaluations, fallback.status);
+    const rawTrustState = result.trustState ?? trustStateFromEvaluations(route, evaluations, fallback.trustState);
+    // A unique semantic grouping may be inferred only under the runtime's
+    // explicit review contract.  Preserve that contract through the generic
+    // engine adapter instead of allowing a successful MetricFlow executor to
+    // silently re-label it as governed.
+    const runtimeReviewRequired = request.askAnalystState?.resolvedPlan?.reviewRequired === true;
+    const status = runtimeReviewRequired && rawStatus === 'completed'
+        ? 'needs_review'
+        : rawStatus;
+    const trustState = runtimeReviewRequired && status !== 'blocked' && status !== 'needs_clarification'
+        ? 'review_required'
+        : rawTrustState;
     // API-007 / AGT-019: a blocked analytical run may carry an intentionally
     // redacted failure envelope needed for inspection and immutable repair. Keep
     // only artifacts that the executor explicitly marked blocked; never retain a
     // governed/reviewable artifact merely because it happened to accompany a
     // terminal failure.
-    const artifacts = status === "blocked"
+    const rawArtifacts = status === "blocked"
         ? (result.artifacts ?? []).filter((artifact) => artifact.trustState === "blocked")
         : result.artifacts ?? defaultArtifacts(route, result, request);
+    const artifacts = runtimeReviewRequired && status !== 'blocked'
+        ? rawArtifacts.map((artifact) => artifact.trustState === 'blocked'
+            ? artifact
+            : { ...artifact, trustState: 'review_required' })
+        : rawArtifacts;
     const stopReason = result.stopReason ?? stopReasonFor(route, status, trustState, artifacts);
     return {
         status,
@@ -3002,19 +4920,45 @@ function computeStepOutcome(route, result, evaluations, request, isClarify, clar
         artifacts,
         stopReason,
         summary: status === "blocked"
-            ? terminalOutcomeMessage ?? blockingOutcomeSummary(evaluations, fallback.summary)
+            ? terminalOutcomeMessage ?? blockingOutcomeSummary(evaluations, result, fallback.summary)
             : result.summary ?? fallback.summary,
         ...(result.answerTier ? { terminalTier: result.answerTier } : {}),
     };
 }
-function blockingOutcomeSummary(evaluations, fallback) {
+/**
+ * The sentence a typed refusal code deserves. These are the honest,
+ * user-actionable readings; the coarse code is still what machines branch on.
+ */
+function refusalCodeSummary(code) {
+    switch (code) {
+        case 'grounding_gap': return 'DQL could not ground every part of this question in the current metadata snapshot, so no query was accepted.';
+        case 'modeling_gap': return 'Part of this question is not modeled in this project yet, so no governed query can answer it as asked.';
+        case 'ambiguous': return 'One business choice is required before DQL can run this question.';
+        case 'provider_error': return 'The AI provider could not complete this Ask step.';
+        case 'orchestration_budget_exhausted': return 'DQL stopped this run at its own orchestration budget before the question was settled.';
+        case 'policy_blocked': return 'A governance policy blocked this request before execution.';
+        case 'execution_error': return 'The selected governed query did not complete on the current connection.';
+        default: return undefined;
+    }
+}
+function blockingOutcomeSummary(evaluations, result, fallback) {
     const messages = evaluations
         .filter((evaluation) => !evaluation.passed && evaluation.severity === 'blocking')
         .map((evaluation) => evaluation.message.trim())
         .filter(Boolean);
-    return messages[0] ?? (fallback.includes('Answered')
-        ? 'The analytical result did not pass its required validation and was not accepted.'
-        : fallback);
+    if (messages[0])
+        return messages[0];
+    // A typed refusal is the truth this run actually recorded. The old fallback
+    // fabricated "did not pass its required validation" whenever no evaluation
+    // was blocking and the route's default summary contained "Answered" — it
+    // asserted a validation that never ran, and masked deadline/budget/gap
+    // terminals behind an invented one.
+    const typed = refusalCodeSummary(result.answerRefusalCode);
+    if (typed)
+        return typed;
+    return fallback.includes('Answered')
+        ? 'The run stopped before an answer was accepted. Open the trace for the exact boundary.'
+        : fallback;
 }
 function consumeRepeatedClarificationSelection(request, routeDecision, result) {
     const selectedEvidenceId = request.selectedEvidenceId;
@@ -3035,6 +4979,48 @@ function consumeRepeatedClarificationSelection(request, routeDecision, result) {
         answer: message,
     };
 }
+/**
+ * Rehydrate the server-owned compiler decision for one frozen Ask task.  The
+ * outer decision remains the durable turn summary, while this scoped view is
+ * the sole authority passed to the executor/evaluator for the current step.
+ */
+function taskScopedRouteDecision(outer, task) {
+    return {
+        ...task.compilerDecision,
+        // The task compiler consumes its canonical local semantic execution ID
+        // (for example `semantic:account_revenue:revenue`), while the persisted
+        // meaning receipt must retain the exact qualified candidate selected by
+        // the immutable planner (`semantic:metric:account_revenue.revenue`).
+        // Preserve that reader-facing identity without changing the frozen
+        // compiler plan or allowing a task to reinterpret meaning.
+        meaningResolution: {
+            ...task.meaningResolution,
+            ...(outer.meaningResolution?.recommendedExecutionId
+                ? { recommendedExecutionId: outer.meaningResolution.recommendedExecutionId }
+                : {}),
+        },
+        // Preserve the root V2 runtime carrier across the frozen-task scope.  It
+        // contains only server-owned snapshot/tool observations and is the source
+        // of a physical provider preflight outcome; dropping it here caused a
+        // child request to persist a generic blocked result instead of its typed
+        // provider diagnostic.
+        ...(outer.askAgentV2Decision ? { askAgentV2Decision: outer.askAgentV2Decision } : {}),
+        ...(outer.providerFailure ? { providerFailure: outer.providerFailure } : {}),
+        // `compileVerifiedAskTasks` accepts a task only after the compiler broker
+        // supplied its complete resolved-plan authority. Do not manufacture a
+        // legacy resolved plan here from a V2 receipt.
+        ...(task.compilerDecision.resolvedAnalyticalPlan
+            ? { resolvedAnalyticalPlan: task.compilerDecision.resolvedAnalyticalPlan }
+            : {}),
+        askAnalystDecision: {
+            version: 1,
+            mode: outer.askAnalystDecision?.mode ?? 'authoritative',
+            state: task.state,
+            resolvedPlan: task.resolvedPlan,
+            ...(outer.askAnalystDecision?.frozenPlan ? { frozenPlan: outer.askAnalystDecision.frozenPlan } : {}),
+        },
+    };
+}
 function isTerminalSuccess(route, outcome) {
     // A completed certified answer is the terminal success — no further steps add trust.
     // A conversational reply is likewise terminal (there is no data work to chain).
@@ -3195,6 +5181,21 @@ export function selectRoute(request, decision) {
         return 'blocked';
     if (decision.action === 'block')
         return 'blocked';
+    // A unique Tier 1 artifact may be proven complete by the authoritative V2
+    // retrieval workspace before any provider turn.  Treat that host-owned
+    // result as a route selection, not as a V1 business interpretation or an
+    // instruction for the model to rediscover the same block.  The artifact is
+    // still rechecked and frozen only at the V2 execution-capability boundary.
+    const v2State = decision.askAgentV2Decision?.mode === 'authoritative_v2'
+        ? decision.askAgentV2Decision.state
+        : undefined;
+    const v2ExactCertified = decision.action === 'answer'
+        && decision.requiresClarification !== true
+        && Boolean(v2State?.exactCertifiedCandidateId
+            && v2State.tierStates?.certified?.status === 'complete'
+            && v2State.tierStates.certified.candidateIds.includes(v2State.exactCertifiedCandidateId));
+    if (v2ExactCertified)
+        return 'certified_answer';
     const authoritativePlan = decision.resolvedAnalyticalPlan?.mode === 'authoritative'
         ? decision.resolvedAnalyticalPlan
         : undefined;
@@ -3444,6 +5445,11 @@ function stopReasonFor(route, status, trustState, artifacts) {
         return "cancelled";
     if (status === "blocked" || trustState === "blocked")
         return "blocked";
+    // A semantic result may be executable yet require review because the
+    // runtime used one declared inferred grouping. Other reviewable authoring
+    // routes keep their existing artifact-created stop semantics.
+    if (route === "semantic_answer" && (status === "needs_review" || trustState === "review_required"))
+        return "human_review_required";
     if (route === "conversation")
         return "conversational_reply";
     if (status === "needs_clarification")
@@ -3454,8 +5460,6 @@ function stopReasonFor(route, status, trustState, artifacts) {
         return "governed_semantic_answer";
     if (artifacts.length > 0 && route !== "generated_answer")
         return "artifact_created";
-    if (status === "needs_review")
-        return "human_review_required";
     return "generated_review_required";
 }
 function defaultNextActions(route, status) {