agent-nuvira 3.3.12 → 3.3.14

package/dist/cli/chat.js

@@ -5,13 +5,14 @@ import { Command } from 'commander';
 import inquirer from 'inquirer';
 import { BaseCommand } from './commands.js';
 import { resolveProvider } from './router.js';
-import { resolveRoute } from '../inference/route-resolver.js';
+import { resolveRoute, strictModelMode, strictPinRefusal } from '../inference/route-resolver.js';
 import { showModelPicker } from './model-picker.js';
 import { ContextParser } from '../context/parser.js';
 import { getCache } from '../context/cache.js';
 import { assembleContext, retrievalOptionsFromConfig, recordRetrievalStats } from '../learning/retrieval.js';
 import { getChatHistory } from '../context/history.js';
 import { maybeAutoRecall, recallContextBlock } from '../context/session-recall.js';
+import { decisionsRecordingEnabled, recallDecisionBlock } from '../learning/decision-log.js';
 import { getMemoryManager } from '../memory/manager.js';
 import { logger } from '../utils/logger.js';
 import { printOrchestrationResult } from './execute.js';
@@ -24,12 +25,17 @@ import { closeResume, openResume, resolveResumeRequest, } from '../learning/step
 import { applyActiveModel } from './model.js';
 import { capabilityReasoningEffort, isMaxCapability } from '../config/capability-mode.js';
 import { getProviderFallback, classifyFallbackError, isRetryableError, isTransientForRetry, recordRegistrySuccess } from '../learning/provider-fallback.js';
-import { recordActionFailure } from '../learning/failure-bookkeeping.js';
+import { recordActionFailure, } from '../learning/failure-bookkeeping.js';
+import { getRouterBandit } from '../learning/router-bandit.js';
+import { UnusableModelResponseError } from '../learning/response-usability.js';
 import { resolveThreadBudgetChars } from '../learning/context-budget.js';
-import { getAutoRouter, isAutoModel, isAutoProvider, governanceVerdict } from '../learning/auto-router.js';
+import { getAutoRouter, isAgentAutoRoute, isAutoModel, isAutoProvider, governanceVerdict, adminBudgetVerdict } from '../learning/auto-router.js';
 import { continuationSoftwareText } from '../learning/continuation-intent.js';
+import { TaskModelContinuity, taskSignature } from '../learning/task-model-continuity.js';
+import { describeFailureKind, renderExhaustionReport, } from '../learning/exhaustion-report.js';
 import { estimateTokens } from '../learning/cost-tracker.js';
 import { getModelRegistry } from '../learning/model-registry.js';
+import { costSince } from '../learning/cost-tracker.js';
 import { refreshModelRegistry } from '../inference/model-probe.js';
 import { startWarmupDaemon } from '../learning/model-warmup.js';
 import { recordRoutingDecision } from '../learning/routing-history.js';
@@ -47,12 +53,15 @@ import { runToolLoop, extractFallbackToolCalls } from '../tools/tool-loop.js';
 import { flushSpans, otelNoticeOnce, startTurnSpan } from '../observability/otel.js';
 import { detectAnswerQualityFailure, answerQualityError, toUserFacingGenerationError, isToolCallingUnsupported, stripToolCallArtifacts, } from '../inference/tool-call-utils.js';
 import { beginTrace, endTrace, recordStep, recordTraceEvent, recordTraceFindings, recordTurnReport, buildTraceOutcome, traceOutcomeSucceeded } from '../learning/reasoning-trace.js';
-import { recordWorkingState, getWorkingState, formatWorkingState, isProjectLedgerDir } from '../learning/working-state.js';
+import { recordWorkingState, getWorkingState, formatWorkingState, isProjectLedgerDir, detectRegressionSignal } from '../learning/working-state.js';
+import { recordDeliverableCandidate, markLastDeliverableRejected } from '../learning/deliverable-corpus.js';
+import { deriveAndApplyBehaviouralLabel } from '../learning/behavioural-labels.js';
 import { getLoopExposureMode } from '../tools/toolsets.js';
 import { resolveModelHarnessProfile, shouldSkipNativeTools, isAgenticCapableModel } from '../learning/model-harness.js';
 import { assertAgenticRoute, setWeakModelConsent, resolveWeakModelPolicy, weakRouteNotice } from '../learning/agentic-route-gate.js';
 import { resolvePromptBudget, measurePromptBudget, formatPromptBudgetBreakdown } from '../learning/prompt-budget.js';
 import { buildTurnReport, formatTurnReport } from '../learning/turn-report.js';
+import { turnOutcomeObservation } from '../learning/outcome-observation.js';
 import { resolveAdapterDefault, hasCredentials } from '../learning/model-selection.js';
 import { buildLoopProjectContext } from '../tools/loop-project-context.js';
 import { sweepTransientFailures, collectionRevivalStore } from '../learning/provider-revival.js';
@@ -360,7 +369,10 @@ export function turnCarriesHonestyFlag(result) {
         result.unverifiedBuildClaim ||
         result.unverifiedEdit ||
         result.unverifiedEditClaim ||
-        result.noActionTaken);
+        result.noActionTaken ||
+        result.artifactIncomplete ||
+        result.unverifiedFileClaim ||
+        result.artifactShortfall);
 }
 // ─── ChatCommand ────────────────────────────────────────────────────────────
 export class ChatCommand extends BaseCommand {
@@ -391,6 +403,40 @@ export class ChatCommand extends BaseCommand {
      * rate-limited (a genuinely shared limit).
      */
     sessionFailedModels = new Map();
+    /**
+     * P3 (fix_model_routing) — task-level model CONTINUITY.
+     *
+     * The pair that produced usable work for a task is remembered per task
+     * signature, and the next turn of the SAME task (a "resume"/"continue" whose
+     * routing text resolves to the same ask) offers it FIRST. Routing re-decides
+     * every turn, and a signal-free continuation re-decided from scratch is how a
+     * working run degraded onto a model that then answered with nothing.
+     *
+     * A preference, never a pin: the recalled pair goes through the SAME
+     * credential/exclusion/registry gates as any other candidate, and the normal
+     * pool stands behind it — so a model that has since died costs one check.
+     */
+    taskContinuity = new TaskModelContinuity();
+    /** The task signature of the turn being routed (see routeMessageAuto). */
+    lastTaskSignature;
+    /**
+     * P4 (fix_model_routing) — what THIS turn actually tried, and why each
+     * candidate did not answer. Reset per turn; consumed by the exhaustion report
+     * when a turn ends without an answer. Chat's own failover walk is the
+     * authority here (the shared walk in `resilient-call.ts` keeps its own log for
+     * the gateway/orchestrator paths), so the report can name the models the user
+     * was actually served by — not a pool that was considered.
+     */
+    turnAttempts = [];
+    /** Record one failed/skipped attempt for this turn's exhaustion report. */
+    recordTurnAttempt(attempt) {
+        try {
+            this.turnAttempts.push(attempt);
+        }
+        catch {
+            // Best-effort — telemetry must never break a turn.
+        }
+    }
     // RATE_LIMIT_EXCLUSION_MS + TRANSIENT_FAILURE_EXCLUSION_MS now live in
     // src/learning/failure-bookkeeping.ts (shared with every action) — see
     // recordActionFailure. Behavior is identical: same values, same semantics.
@@ -478,7 +524,10 @@ export class ChatCommand extends BaseCommand {
                 // Best-effort — an unreadable config leaves the previous behavior.
             }
         }
-        let autoMode = isAutoModel(mergedOpts.model) || isAutoProvider(mergedOpts.provider);
+        // A8 — a CONCRETE provider with `-m auto` means that provider's own auto
+        // (e.g. an OmniRoute combo), NOT our auto-route. isAgentAutoRoute excludes
+        // that case so the pin reaches the provider instead of being re-routed.
+        let autoMode = isAgentAutoRoute(mergedOpts.provider, mergedOpts.model);
         let { type, provider } = autoMode
             ? await this.getProvider({})
             : await this.getProvider(mergedOpts);
@@ -486,6 +535,11 @@ export class ChatCommand extends BaseCommand {
         // B — captured from the route so the post-route capability gate below can
         // judge the FINAL pair without re-resolving anything.
         let routeVerdict;
+        // C6 — the turn's economy window, taken before the FIRST provider call. The
+        // turn report states what THIS turn cost from the persisted ledger; a
+        // continuation or a resumed turn runs in a fresh process, so a session
+        // counter would report zero for it (`costSince` reads timestamps instead).
+        const turnCostSince = Date.now();
         let routedText;
         if (autoMode) {
             // Intent-aware escalation: a bare "yes"/"do it" continuing software work
@@ -606,9 +660,27 @@ export class ChatCommand extends BaseCommand {
                 recallBlock = undefined;
             }
         }
+        // Decision recall — the SAME attached project's recorded decisions
+        // (`.nuvira/decisions.jsonl`), when this ask actually mentions one. It is
+        // ADVISORY: it is injected as context and NEVER suppresses an `ask_user`, so
+        // a situation that has changed can still ask. Best-effort: an empty log (or
+        // no matching token) injects nothing, and a read failure never breaks the
+        // turn. Gated by `decisionsRecordingEnabled()` so a test-run turn is inert
+        // unless it explicitly opts in (NUVIRA_DECISION_LOG=on).
+        let decisionBlock;
+        if (opts.projectPath && decisionsRecordingEnabled()) {
+            try {
+                const block = recallDecisionBlock(opts.projectPath, message, 3);
+                if (block)
+                    decisionBlock = block;
+            }
+            catch {
+                decisionBlock = undefined;
+            }
+        }
         const parsed = parseRequestSync(message);
         const dispatchDecision = resolvePipelineDispatch(parsed, { dev: opts.dev, text: message });
-        const answer = await this.runChatAnswer(message, opts.history ?? [], { type, provider, model }, { provider: mergedOpts.provider, model: mergedOpts.model, dev: mergedOpts.dev, cache: true }, true, { auto: autoMode }, parsed, { askUser: opts.askUser, onProgress: opts.onProgress, onToolCall: opts.onToolCall, onPlanChange: opts.onPlanChange, onGitDiff: opts.onGitDiff, onSkillDraft: opts.onSkillDraft, onFinding: opts.onFinding, planStore: opts.planStore ?? this.planStore, gateway: opts.gateway, projectContext: opts.projectContext, recallContext: recallBlock, projectPath: opts.projectPath, onToken: opts.onToken, signal: opts.signal, continuation: opts.continuation, systemPolicy: opts.systemPolicy, debugSurface: opts.debugSurface ?? 'cli-chat', debugSession: opts.debugSession, worktree: opts.worktree, keepWorktree: opts.keepWorktree, resume: opts.resume });
+        const answer = await this.runChatAnswer(message, opts.history ?? [], { type, provider, model }, { provider: mergedOpts.provider, model: mergedOpts.model, dev: mergedOpts.dev, cache: true }, true, { auto: autoMode }, parsed, { askUser: opts.askUser, onProgress: opts.onProgress, onToolCall: opts.onToolCall, onPlanChange: opts.onPlanChange, onGitDiff: opts.onGitDiff, onSkillDraft: opts.onSkillDraft, onFinding: opts.onFinding, planStore: opts.planStore ?? this.planStore, gateway: opts.gateway, projectContext: opts.projectContext, recallContext: recallBlock, decisionContext: decisionBlock, projectPath: opts.projectPath, onToken: opts.onToken, signal: opts.signal, continuation: opts.continuation, systemPolicy: opts.systemPolicy, debugSurface: opts.debugSurface ?? 'cli-chat', debugSession: opts.debugSession, worktree: opts.worktree, keepWorktree: opts.keepWorktree, resume: opts.resume });
         // No-model fallback: the tool loop could not generate a single response
         // AND the rules assessed a high-confidence pipeline intent — run the
         // pipeline directly (rules decide only when the model is unavailable; the
@@ -619,6 +691,15 @@ export class ChatCommand extends BaseCommand {
         // dispatching it here would run the ask on another engine entirely — the one
         // path that can run it UNISOLATED while the caller asked for isolation.
         if (answer.generationFailed && !answer.refused && dispatchDecision.dispatch && !dispatchDecision.needConfirm) {
+            // E2 — this CHANGES THE EXECUTION MODEL: the ask leaves the single chat tool
+            // loop and runs as a multi-agent pipeline. Falling back is legitimate
+            // (nothing was generated), but it must never be silent. A pinned ask that
+            // flips engines without saying so is the same defect as an unattended
+            // auto-pick reported as the user's own choice: the user is owed the reason
+            // and the fact that their pin is the pair being carried over.
+            opts.onProgress?.(`   ⤵️ the chat turn produced no answer on ${provider.name}${model ? ` / ${model}` : ''} — ` +
+                `running this ask in the multi-agent pipeline instead (a different execution model` +
+                `${autoMode ? '' : ', on the same pinned pair'})`);
             const r = await runPipelineTool(message, this.configManager, { provider: type, model, board: false });
             // `success`, not `error`: a pipeline that RAN and failed reports its
             // outcome in `summary` and only sometimes sets `error`, so keying off
@@ -664,6 +745,16 @@ export class ChatCommand extends BaseCommand {
                 successfulToolCalls: answer.successfulToolCalls,
                 mutations: answer.runTrace?.mutations,
                 changedPaths: answer.runTrace?.paths,
+                // E1 — decisions the harness took on the user's behalf (an unattended
+                // ask_user default), so the report discloses them instead of letting the
+                // answer read as a choice the user made.
+                assumptions: answer.runTrace?.assumptions,
+                // C6 — what the turn cost, from the ledger, so an expensive turn is visible
+                // where the turn is described instead of only in a session total.
+                cost: (() => {
+                    const spend = costSince(turnCostSince);
+                    return { usd: spend.costUsd, tokens: spend.tokens, calls: spend.requests };
+                })(),
                 flags: {
                     unverifiedActionClaim: answer.unverifiedActionClaim,
                     unverifiedEdit: answer.unverifiedEdit,
@@ -672,6 +763,15 @@ export class ChatCommand extends BaseCommand {
                     undeliveredArtifact: answer.undeliveredArtifact,
                     unfulfilledPromise: answer.unfulfilledPromise,
                     noActionTaken: answer.noActionTaken,
+                    // Bundle 19 — the artifact's own admission travels to the report, so the
+                    // turn cannot read as finished work on any surface that shows it.
+                    incompleteArtifactClaim: Boolean(answer.artifactIncomplete),
+                    // Bundle 20 — a fabricated "I wrote the file" reaches the report for the
+                    // same reason: no surface may read such a turn as finished work.
+                    unverifiedFileClaim: Boolean(answer.unverifiedFileClaim),
+                    // Bundle 23 — a file far short of the stated magnitude is the same:
+                    // the delivered artifact is not what was asked for.
+                    artifactShortfall: Boolean(answer.artifactShortfall),
                 },
             });
         }
@@ -682,6 +782,109 @@ export class ChatCommand extends BaseCommand {
         // reviewable after the fact (the Trace tab renders it), not only in this
         // turn's return value. Best-effort: a trace write never breaks a turn.
         recordTurnReport(answer.traceId, turnReport);
+        // The user's message for THIS turn is also a verdict on the PREVIOUS one
+        // ("still broken", "no change", or a near-identical re-ask). It is resolved
+        // BEFORE this turn's own delivery is recorded, because these signals judge the
+        // PREVIOUS turn — run after the record below, they would label the row this very
+        // turn just created. Derived ONCE here, because two independent consumers need
+        // the same answer: the bandit's `userAccepted` and the deliverable corpus's
+        // label. Neither trusts the model's own account of itself.
+        const userReportsRegression = detectRegressionSignal(message);
+        if (userReportsRegression) {
+            // Label the previous authored delivery as a miss. Independent of routing:
+            // the corpus is collected whether or not the bandit is on.
+            try {
+                markLastDeliverableRejected();
+            }
+            catch {
+                // Collection is best-effort.
+            }
+        }
+        // Tier 3 — the verdict the harness can infer from BEHAVIOUR, when the user did
+        // not report a regression: a re-ask or a hand-edited artifact is a rejection, an
+        // untouched artifact the user then REFERENCES is a (weak) acceptance. Recorded
+        // `source: 'derived'` so a fit can weigh it below an explicit verdict. Stands
+        // aside when a regression was reported — that path already owns the label.
+        if (!userReportsRegression) {
+            try {
+                deriveAndApplyBehaviouralLabel({ newAsk: message, reportsRegression: false });
+            }
+            catch {
+                // Collection is best-effort.
+            }
+        }
+        // Item 13 (round 3) — COLLECT, never judge. An authored artifact that met the
+        // ask's stated magnitude and did not admit its own omission is the "fluent,
+        // on-length" delivery no rule can score; the corpus records it so that a
+        // LATER correction can label it. This is a dataset, not a detector: nothing
+        // reads it, and no score is derived from it. Recorded LAST so the verdict-on-
+        // previous above never sees this turn's own row.
+        if (answer.authoredDeliverable) {
+            try {
+                recordDeliverableCandidate({
+                    ask: message,
+                    path: answer.authoredDeliverable.path,
+                    deliveredWords: answer.authoredDeliverable.deliveredWords,
+                    ...(answer.authoredDeliverable.targetWords !== undefined
+                        ? { targetWords: answer.authoredDeliverable.targetWords }
+                        : {}),
+                    ...(turnReport?.verification ? { verification: turnReport.verification } : {}),
+                    // The trace link is what lets an EXPLICIT verdict (`nuvira rate`) label
+                    // THIS delivery rather than "the most recent one".
+                    ...(answer.traceId ? { traceId: answer.traceId } : {}),
+                    excerpt: answer.authoredDeliverable.excerpt,
+                });
+            }
+            catch {
+                // Collection is best-effort — never break a turn on a corpus write.
+            }
+        }
+        // Feed the MEASURED outcome back into the bandit on the CHAT path too. The
+        // orchestrator has done this for pipeline tasks all along; the chat turn —
+        // the product's most common entry point — never did, so every turn's real
+        // result was thrown away and the router learned from only one of its two
+        // execution models. The signal is the turn report's derived VERIFICATION
+        // verdict, never the model's own account of itself.
+        //
+        // Guarded exactly like the orchestrator: only when this turn was AUTO-routed
+        // (otherwise `getLastProvider` could reward a stale provider noted by an
+        // earlier auto run in this process) and only when bandit learning is on.
+        if (autoMode && this.configManager.getAll().routing?.bandit !== false) {
+            // `userAccepted: false` for the turn that just ran, applied BEFORE this
+            // turn's own outcome is recorded (recording overwrites the attribution the
+            // correction refers to). It is walked up to the previous AUTO-routed turn
+            // only — `recordUserRejection` no-ops when nothing is pending.
+            if (userReportsRegression) {
+                try {
+                    getAutoRouter().recordUserRejection('chat');
+                }
+                catch {
+                    // Learning is best-effort — never break a turn on a bandit error.
+                }
+            }
+            const observation = turnOutcomeObservation(turnReport);
+            if (observation) {
+                try {
+                    getAutoRouter().recordOutcome('chat', message, observation.outcome, this.configManager, observation.outcomeData);
+                }
+                catch {
+                    // Learning is best-effort — never break a turn on a bandit error.
+                }
+                // Bundle 3b: the SAME derived verdict also feeds the capability
+                // scorecard's accuracy parameter for the pair that actually served the
+                // turn. One translation of "did the work verify", two consumers — rather
+                // than a second, parallel notion of success that could drift from it.
+                // `blocked`/`not-applicable` write nothing (see the registry method).
+                try {
+                    if (type && model) {
+                        getModelRegistry().recordCapabilityEvidence(type, model, turnReport?.verification ?? 'not-applicable');
+                    }
+                }
+                catch {
+                    // Learning is best-effort — never break a turn on a scorecard write.
+                }
+            }
+        }
         // E3 — surface a non-trivial report on the console. A plain answer (no
         // plan, nothing changed) produces no summary and stays silent.
         if (turnReport?.summary) {
@@ -701,6 +904,14 @@ export class ChatCommand extends BaseCommand {
             unfulfilledPromise: answer.unfulfilledPromise,
             undeliveredArtifact: answer.undeliveredArtifact,
             unverifiedBuildClaim: answer.unverifiedBuildClaim,
+            // Bundle 19/20 — the reliability flags must not be dropped at this
+            // boundary, or a caller re-deriving the verdict would see a clean turn.
+            artifactIncomplete: answer.artifactIncomplete,
+            unverifiedFileClaim: answer.unverifiedFileClaim,
+            artifactShortfall: answer.artifactShortfall,
+            // Item 13 (round 3) — the collectable "fluent, on-length" delivery travels to
+            // the caller, which records it. Facts only; no verdict is attached here.
+            authoredDeliverable: answer.authoredDeliverable,
             // WS1 — the findings this turn recorded (empty when it recorded none).
             findings: answer.findings ?? [],
             provider: type,
@@ -739,8 +950,8 @@ export class ChatCommand extends BaseCommand {
             .description('Start an interactive chat session with AI')
             .argument('[prompt]', 'Optional initial prompt')
             .option('-f, --file <path>', 'Include file content as context')
-            .option('-p, --provider <provider>', 'Inference provider')
-            .option('-m, --model <model>', 'Model to use (if omitted, an interactive picker will appear)')
+            .option('-p, --provider <provider>', 'Inference provider to pin this chat to')
+            .option('-m, --model <model>', 'Model to pin this chat to (if omitted, an interactive picker will appear)')
             .option('--no-cache', 'Disable response caching')
             .option('-d, --dev', 'Always dispatch requests to the coding pipeline (no confirmation)', false)
             // WS5 (#27) — isolation and partial resume, as the two things an operator
@@ -756,6 +967,12 @@ export class ChatCommand extends BaseCommand {
             .option('--worktree', 'Run this turn in its own git worktree of the project and report the diff against the base commit. Refuses rather than running unisolated when the directory cannot be isolated (also asked for by NUVIRA_ISOLATE=1)')
             .option('--keep-worktree', 'Keep the isolated worktree after the turn instead of removing it')
             .option('--resume [id]', 'Replay the recorded steps of this ask whose input is unchanged instead of paying for them again (defaults to the record for this goal + directory; also asked for by NUVIRA_RESUME=1)')
+            .addHelpText('after', '\nModel routing:\n' +
+            '  Pinning -p/--provider (and -m/--model) does NOT stop the router from falling\n' +
+            '  over to another model if the pinned one is unavailable — auto routing takes\n' +
+            '  over and the turn says so. To work with the pinned model ONLY, set\n' +
+            '  NUVIRA_STRICT_MODEL=1: a dead pin then fails with a message naming the pair\n' +
+            '  instead of substituting another model.\n')
             .action(async (prompt, options) => {
             await this.execute(prompt, options || {});
         });
@@ -782,8 +999,44 @@ export class ChatCommand extends BaseCommand {
         // Apply the active model state from `nuvira model switch` as defaults
         const activeOpts = applyActiveModel({ provider: options?.provider, model: options?.model });
         const mergedOpts = { ...options, provider: activeOpts.provider, model: activeOpts.model };
+        // ── The CONFIG's defaultProvider is a routing directive too ──────────────
+        // When the operator supplies neither a provider nor a model — no `-p`, no
+        // `-m`, no `nuvira model switch` state — the config decides, and the shipped
+        // default is `defaultProvider: "auto"`. This is the CLI's counterpart to the
+        // block in `answerOnce` (see `chat-answer-once-auto-parity.test.ts`, which
+        // pinned the dashboard/gateway side of it in 2026-09-20).
+        //
+        // WHY IT IS LOAD-BEARING, measured 2026-10-06: `execute` — the whole CLI
+        // entry (`-t/--task`, `chat "<task>"`, the REPL) — did NOT honour it. With
+        // neither flag nor active-model state, `autoMode` was `false`, so the turn
+        // took the NON-auto path and `resolveProvider(config, undefined)` resolved
+        // `defaultProvider: "auto"` through `rankAvailableProviders()` to ONE
+        // concrete provider. Everything downstream of the auto router was therefore
+        // skipped on the product's most common entry point: no `routeMessageAuto`
+        // (so no routing-history row to audit which model served the turn, no
+        // routing cache, and no capability gate), no pin pre-flight, and
+        // `model explain` — which DOES use the auto router — predicting a model the
+        // runtime never used. Measured with `NUVIRA_TRACE_ROUTE=1`: a `-t` turn
+        // logged `[TRACE] execute {"autoMode":false,"type":"groq"}` and appended
+        // ZERO rows to routing-history.
+        //
+        // Only the AUTO default changes behaviour: an explicit `-p`/`-m` or a
+        // `model switch` pin is a deliberate choice and keeps the non-auto path
+        // exactly as it is (and is checked FIRST, so a pin can never be re-routed).
+        if (!mergedOpts.provider && !mergedOpts.model) {
+            try {
+                const cfg = this.configManager.getAll();
+                if (isAutoProvider(cfg.defaultProvider))
+                    mergedOpts.provider = cfg.defaultProvider;
+            }
+            catch {
+                // Best-effort — an unreadable config leaves the previous behavior.
+            }
+        }
         // ── Auto routing mode: agent decides the best provider/model per message ──
-        let autoMode = isAutoModel(mergedOpts.model) || isAutoProvider(mergedOpts.provider);
+        // A8 — a pinned concrete provider with `-m auto` is the provider's own auto,
+        // not ours. See isAgentAutoRoute.
+        let autoMode = isAgentAutoRoute(mergedOpts.provider, mergedOpts.model);
         let { type, provider } = autoMode
             ? await this.getProvider({})
             : await this.getProvider(mergedOpts);
@@ -879,6 +1132,10 @@ export class ChatCommand extends BaseCommand {
             // WS5 — never on a REFUSED turn: the pipeline would run it in the real tree
             // (see the guard in `answerOnce`).
             if (answer.generationFailed && !answer.refused && dispatchDecision.dispatch && !dispatchDecision.needConfirm) {
+                // E2 — same rule as `answerOnce`: the engine changes here, so say so.
+                logger.info(`   ⤵️ the chat turn produced no answer on ${provider.name}${model ? ` / ${model}` : ''} — ` +
+                    `running this ask in the multi-agent pipeline instead (a different execution model` +
+                    `${autoMode ? '' : ', on the same pinned pair'})`);
                 await runDeveloperMode(prompt, this.configManager, { provider: type, model });
                 // After pipeline execution, show followups and continue conversation
                 // (don't just return — keep user engaged with next steps)
@@ -1128,7 +1385,20 @@ export class ChatCommand extends BaseCommand {
             ...(ctxOverrides?.debugSession ? { session: ctxOverrides.debugSession } : {}),
             backend: { engine: 'loop', provider: session.type, ...(session.model ? { model: session.model } : {}) },
         });
-        debugLog?.event('turn.start', { provider: session.type });
+        // ── The pair this surface RESOLVED is not the pair that served ───────────
+        // MEASURED (2026-10-07): one log read `# backend.provider: local` /
+        // `# backend.model: qwen2.5:0.5b` while its own first event said
+        // `turn.start {"provider":"gemini"}`. Neither field was computed wrongly —
+        // the header names the pair that ACTUALLY served (via `lastAttempt`, updated
+        // by the provider walk and written at close) and this event named the pair
+        // the turn was CONFIGURED with, before any walk. But a lone `provider` field
+        // in an event called `turn.start` reads as "the turn started on gemini", so
+        // the honest fix is to say which question each field answers: this one is the
+        // REQUESTED route, and `turn.end` now carries the served one from the same
+        // expression as the header, so the two can never disagree.
+        debugLog?.event('turn.start', {
+            requested: session.model ? `${session.type}/${session.model}` : session.type,
+        });
         // WS3 (#25) — the turn's span root, when span export is on (else null). Same
         // identity as the log's: one surface, one conversation, one turn.
         const otelSpan = await startTurnSpan({
@@ -1303,26 +1573,36 @@ export class ChatCommand extends BaseCommand {
         // prompt, so on this surface the MODEL decides and the rules are invisible.
         const systemText = buildToolSystemPrompt(parsed);
         // Skill hint — MODE-DEPENDENT (see resolveSkillHintMode):
-        //   - `match` (default) — the small keyword-matched hint: ONE skill, and
-        //     only when the goal really matches; otherwise nothing. This is the
-        //     3.3.10 behaviour and keeps the prompt small.
+        //   - `pointer` (default) — a bounded discovery pointer: skills exist, here
+        //     are the two ways to find one (the `skill` tool and the capability
+        //     search). The MODEL picks; the harness no longer keyword-matches. This
+        //     keeps the prompt small and has no false positives to maintain.
         //   - `catalog` (opt-in) — the full name+description catalog, which lets the
-        //     MODEL pick a skill but costs ~24K chars on every turn, so it must be
-        //     chosen (`NUVIRA_SKILL_CATALOG=catalog` or `skills.catalogHint`).
+        //     model read every skill in-context but costs ~24K chars on every turn,
+        //     so it must be chosen (`NUVIRA_SKILL_CATALOG=catalog` or
+        //     `skills.catalogHint`).
         //   - `off` — never inject one.
         // Best-effort: any failure returns '' and the turn proceeds byte-identically.
         let skillHint = '';
         try {
-            const { buildConfiguredSkillHint, markLoopSkillUsed } = await import('../tools/loop-skill-hint.js');
-            const injected = {
-                value: null,
-            };
-            skillHint = await buildConfiguredSkillHint(message, this.configManager, injected);
-            await markLoopSkillUsed(injected.value);
+            const { buildConfiguredSkillHint } = await import('../tools/loop-skill-hint.js');
+            skillHint = await buildConfiguredSkillHint(this.configManager);
         }
         catch {
             skillHint = ''; // best-effort — a hint failure never breaks the turn
         }
+        // Machine facts — the host stated ONCE (OS / arch / shell / installed package
+        // managers), so the model chooses a command for THIS machine instead of
+        // assuming one. Detected once per process; best-effort (a detection failure
+        // injects nothing and the turn proceeds byte-identically).
+        let machineBlock = '';
+        try {
+            const { buildMachineFactsBlock } = await import('../learning/machine-facts.js');
+            machineBlock = buildMachineFactsBlock();
+        }
+        catch {
+            machineBlock = '';
+        }
         // `-f/--file` file-context parity: the legacy generateWithContext loaded
         // + retrieval-reduced file context. Inject it as a context message before
         // the user's message so the tool-loop path keeps the flag working.
@@ -1358,6 +1638,25 @@ export class ChatCommand extends BaseCommand {
                 ambientProjectContext = undefined;
             }
         }
+        // Phase 1 — deterministic, tag-scoped knowledge. A message that OPENS with
+        // `#tag` retrieves that tag's relevant passages and puts them in front of
+        // the model before the question. It is INERT otherwise: with no marker (or
+        // with no tags defined at all) the builder returns an empty block WITHOUT
+        // touching the embedder, so a turn that did not ask for a document is
+        // byte-identical to one from a build without this feature — no extra cost,
+        // no extra noise, and never a wrong corpus. Dynamically imported so the
+        // retrieval modules are not loaded on a turn that will not use them, the
+        // same best-effort contract as the ambient project context above. See
+        // src/learning/knowledge-turn.ts for what the guarantee rests on.
+        let knowledgeBlock = '';
+        try {
+            const { buildKnowledgeTurnContext } = await import('../learning/knowledge-turn.js');
+            const knowledge = await buildKnowledgeTurnContext(message);
+            knowledgeBlock = knowledge.block;
+        }
+        catch {
+            knowledgeBlock = ''; // best-effort — a retrieval failure never breaks the turn
+        }
         // G4 — carry THIS project's working state (files changed, verification debt,
         // user-reported regressions) into the turn, so the model does not re-derive
         // what previous turns already established. This is the fix for the
@@ -1379,7 +1678,7 @@ export class ChatCommand extends BaseCommand {
         // turn, where it used to occupy ~80% of the ask on WhatsApp turns.
         const systemPolicyBlock = ctxOverrides?.systemPolicy ? `\n\n${ctxOverrides.systemPolicy}` : '';
         const thread = [
-            { role: 'system', content: systemText + systemPolicyBlock + skillHint },
+            { role: 'system', content: systemText + systemPolicyBlock + machineBlock + skillHint },
             // P3 — the attached project's bounded snapshot (path + file tree +
             // symbol map) rides in before the conversation, exactly like --file
             // context: the model knows what it is looking at without being told.
@@ -1390,11 +1689,22 @@ export class ChatCommand extends BaseCommand {
                 : ambientProjectContext
                     ? [{ role: 'user', content: `[Project context]\n${ambientProjectContext}` }]
                     : []),
+            // Phase 1 — the tagged knowledge this ask selected, when it selected one.
+            // It sits with the other CONTEXT blocks (before the history) so the
+            // conversation stays contiguous, and it is a USER-TURN message rather than
+            // system text, so the system prompt stays byte-stable and cacheable.
+            ...(knowledgeBlock ? [{ role: 'user', content: knowledgeBlock }] : []),
             // P4 — the recalled project context (prior sessions + facts) rides in
             // next, so the model starts from what this project was last doing.
             ...(ctxOverrides?.recallContext
                 ? [{ role: 'user', content: ctxOverrides.recallContext }]
                 : []),
+            // Decision recall — the ADVISORY standing answers this project recorded
+            // for related asks. Sits with the other context blocks, and is deliberately
+            // never used to suppress an `ask_user`.
+            ...(ctxOverrides?.decisionContext
+                ? [{ role: 'user', content: ctxOverrides.decisionContext }]
+                : []),
             // G4 — the deterministic working-state ledger (never a summary).
             ...(workingStateBlock ? [{ role: 'user', content: workingStateBlock }] : []),
             ...(fileContext
@@ -1446,6 +1756,18 @@ export class ChatCommand extends BaseCommand {
             // P4 — when a project is attached, scope tools to its root so the
             // agent operates inside the project (not the dashboard server's cwd).
             cwd: turnCwd,
+            // Cluster G — the surface's own verdict on whether `turnCwd` is the
+            // user's workspace. `false` means this is an unscoped turn (no attachment,
+            // no folder named in the message, no configured default), so `turnCwd` is
+            // the dashboard process's own directory — a place that belongs to nobody.
+            // A write there must ask; see `unscopedWriteRefusal` in coding-tools.ts.
+            ...(ctxOverrides?.unscopedWorkspace ? { workspaceUnscoped: true } : {}),
+            // P7 — is a PERSON watching this turn? It decides `run_terminal`'s DEFAULT
+            // command timeout (60s here vs 120s unattended): two minutes of silence in
+            // front of someone is not patience, it is a bug — the live run spent four
+            // minutes on back-to-back 120-second timeouts while the console showed
+            // nothing, then gave up.
+            interactive: Boolean(ctxOverrides?.askUser) || Boolean(process.stdin.isTTY),
             emit: (event, data, source) => {
                 // G3 — collect mutated file paths from `tool:started` (which carries
                 // the arguments) so the working-state ledger knows what changed.
@@ -1613,7 +1935,11 @@ export class ChatCommand extends BaseCommand {
                 { name: 'system:identity+tool-contract', chars: systemText.length },
                 { name: 'system:channel-policy', chars: systemPolicyBlock.length },
                 { name: 'skill-hint', chars: skillHint.length, dropPriority: 10 },
+                // Machine facts are FACTS about the host, not a recommendation, so they
+                // drop LAST among the optional blocks (higher priority = kept longer).
+                { name: 'machine-facts', chars: machineBlock.length, dropPriority: 15 },
                 { name: 'working-state', chars: workingStateBlock.length, dropPriority: 25 },
+                { name: 'decisions', chars: ctxOverrides?.decisionContext?.length ?? 0, dropPriority: 28 },
                 { name: 'recall', chars: ctxOverrides?.recallContext?.length ?? 0, dropPriority: 30 },
                 {
                     name: 'project-context',
@@ -1623,10 +1949,17 @@ export class ChatCommand extends BaseCommand {
                 { name: 'file-context', chars: fileContext?.length ?? 0, dropPriority: 45 },
                 { name: 'history+ask', chars: historyChars },
             ], { budget: contextBudget });
-            // Apply the FIRST ladder step (the documented, safe one): drop the skill
-            // hint from the assembled system message.
-            if (report.trims.includes('skill-hint') && skillHint) {
-                thread[0] = { role: 'system', content: systemText + systemPolicyBlock };
+            // Apply the ladder steps: drop the optional system blocks the budget names,
+            // rebuilding the system message from the survivors.
+            const trimmed = new Set(report.trims);
+            if ((trimmed.has('skill-hint') || trimmed.has('machine-facts')) && (skillHint || machineBlock)) {
+                thread[0] = {
+                    role: 'system',
+                    content: systemText +
+                        systemPolicyBlock +
+                        (trimmed.has('machine-facts') ? '' : machineBlock) +
+                        (trimmed.has('skill-hint') ? '' : skillHint),
+                };
             }
             if (report.level !== 'ok') {
                 recordTraceEvent(chatTraceId, {
@@ -1643,6 +1976,9 @@ export class ChatCommand extends BaseCommand {
         // The instant this turn's model walk began. A failed generation records the
         // WALK (below) relative to this mark, so the trace can say what was tried. 
         const modelWalkMark = Date.now();
+        // P4 — a fresh attempt log for this turn (the report is about what THIS turn
+        // tried, never a stale list from an earlier one).
+        this.turnAttempts = [];
         const seenStepDigests = new Set();
         const digestPrompt = (p) => {
             try {
@@ -1706,6 +2042,146 @@ export class ChatCommand extends BaseCommand {
                 throw err;
             }
         };
+        /**
+         * P2 (fix_model_routing) — MID-TURN MODEL HANDOFF.
+         *
+         * The tool loop calls this when the model serving the turn resolved with
+         * NOTHING usable (no answer text, no tool call) and has already had its one
+         * retry. Until now that case re-asked the SAME model: a live dashboard run
+         * took five consecutive empty responses from `local/gpt-oss:120b-cloud` and
+         * ended as `bounded` with zero tool calls, while a healthy Gemini model sat
+         * configured and unused — the user had to say "retry". The loop owns the
+         * retry policy; this owns the POOL.
+         *
+         * Order of business, and why:
+         *   1. Exclude the pair that returned nothing — MODEL-scoped, never the
+         *      provider. Free tiers meter per model, so the provider's next-best
+         *      model is usually perfectly healthy, and `pushCandidate` in the deep
+         *      pool already honours this model-scoped exclusion set.
+         *   2. Auto turns re-resolve through the same deep pool the first route used,
+         *      first WITHOUT excluding the provider (its sibling models are the
+         *      cheapest, lowest-latency handoff) and then WITH it, so a provider
+         *      whose only models are dead is genuinely left behind.
+         *   3. A pinned (non-auto) turn walks the configured fallback chain, and
+         *      honours `strictModelMode()` by refusing to substitute at all — the
+         *      same rule the thrown-error failover already follows.
+         *
+         * Resolving `false` is honest: it means no other candidate exists, and the
+         * loop then falls back to its own bounded escalation instead of spinning.
+         */
+        const requestModelSwitch = async () => {
+            const failedModel = session.model;
+            // P4 — this pair is one of the models the turn actually tried, and it
+            // failed by answering with nothing. Recorded here because the report has
+            // to name it, and because "the provider returned an empty response" is a
+            // cause the user should see instead of a generic apology.
+            this.recordTurnAttempt({
+                provider: session.type,
+                model: failedModel ?? 'default',
+                kind: 'empty-response',
+                reason: describeFailureKind('empty-response'),
+            });
+            // ── RC2: the failure must be LEARNED, not just survived ───────────────
+            // The session exclusion alone only lasts this turn: the model stayed
+            // `verified` with `errorRate` 0 across sessions, so the very next chat
+            // could route to it again. `recordAutoProviderFailure` runs the FULL
+            // shared composition for the pair — session exclusion (model-scoped),
+            // registry write-through (which parks it for EMPTY_RESPONSE_PARK_MS), the
+            // quota-timeline event, and the shared breaker (deliberately skipped for
+            // an empty response: the breaker is provider-scoped and the provider was
+            // fine). One `empty-response` failure nobody wrote down was the whole
+            // reason a dead model kept its "verified" badge.
+            try {
+                this.recordAutoProviderFailure(session.type, new UnusableModelResponseError('empty', 'the provider returned nothing usable for this step'), failedModel);
+            }
+            catch {
+                // Best-effort — bookkeeping must never break the turn.
+            }
+            // P6 — and the bandit hears about it too: a step-level empty is NEGATIVE
+            // evidence for this model in the arm the router samples (see
+            // `RouterBandit.penalizeModel`), so the score that flipped a working run to
+            // a broken model can actually decay.
+            if (failedModel && failedModel !== 'default') {
+                try {
+                    getRouterBandit().penalizeModel(failedModel, this.lastRouteSnapshot?.complexity ?? undefined, this.lastTaskSignature?.split('|')[0]);
+                }
+                catch {
+                    // Best-effort — learning must never break the turn.
+                }
+            }
+            /** Install a candidate and report whether it is genuinely a NEW pair. */
+            const install = (next) => {
+                const current = `${session.type}|${session.model ?? 'default'}`;
+                const pair = `${next.type}|${next.model ?? 'default'}`;
+                if (pair === current)
+                    return false;
+                session.type = next.type;
+                session.provider = next.provider;
+                if (next.model && next.model !== 'default')
+                    session.model = next.model;
+                this.lastAttempt = { provider: next.type, model: next.model };
+                logger.warn(`   🔀 ${current} returned nothing usable — handing the turn to ${pair}`);
+                return true;
+            };
+            if (mode.auto) {
+                // First keep the provider (its sibling models are the cheapest handoff),
+                // then drop the provider entirely so a fully-dead provider is left behind.
+                // The same intent hint the initial route and the failover walk use: a
+                // bare continuation ("resume") must re-route on the ask it continues,
+                // not on the signal-free word, or the handoff lands on a trivial model.
+                const switchRoutingText = continuationSoftwareText(message, history) ?? undefined;
+                for (const excludeProviders of [[], [session.type]]) {
+                    try {
+                        const next = await this.routeMessageAuto(message, excludeProviders, {
+                            ...(switchRoutingText ? { routingText: switchRoutingText } : {}),
+                            fallbackFrom: session.type,
+                            // A handoff must NEVER reuse a decision computed before the failure
+                            // it is reacting to. The 30-second routing cache is keyed on inputs
+                            // that do not include the pair we just excluded, so a cached
+                            // decision could hand back the SAME model — making the handoff a
+                            // no-op and ending a recoverable turn. Observed shape: two routing
+                            // decisions 17 seconds apart carrying an identical score, one of
+                            // them a failover the cache had never re-evaluated.
+                            noCache: true,
+                        });
+                        if (install(next))
+                            return true;
+                    }
+                    catch {
+                        // Unresolvable through this shape — try the next one.
+                    }
+                }
+                return false;
+            }
+            // A pinned turn: never substitute a model the user explicitly forbade.
+            if (strictModelMode())
+                return false;
+            try {
+                const chain = getProviderFallback(this.configManager, this.configManager.getAll().fallback)
+                    .getFallbackChain(session.type);
+                for (const fbType of chain) {
+                    if (fbType === session.type)
+                        continue;
+                    if (!hasCredentials(this.configManager, fbType))
+                        continue;
+                    if (!governanceVerdict(this.configManager, fbType, { taskText: message }).allowed)
+                        continue;
+                    try {
+                        const resolved = resolveProvider(this.configManager, fbType);
+                        const model = getAutoRouter().resolveModel(fbType, 'chat', this.configManager);
+                        if (install({ type: resolved.type, provider: resolved.provider, model }))
+                            return true;
+                    }
+                    catch {
+                        // Next fallback candidate.
+                    }
+                }
+            }
+            catch {
+                // Fall through to `false` — the loop's bounded path still applies.
+            }
+            return false;
+        };
         try {
             // R1 — the harness follows the MODEL, not only the config: config says
             // what this deployment prefers, the profile decides what this model can
@@ -1747,6 +2223,13 @@ export class ChatCommand extends BaseCommand {
                 onTraceEvent: (event) => recordTraceEvent(chatTraceId, event),
                 deps: {
                     callModel: callModelWithTrace,
+                    // P2 — the empty-response handoff (see `requestModelSwitch` above).
+                    requestModelSwitch,
+                    // C5 — `requestModelSwitch` installs the replacement on `session`, so
+                    // re-resolve the thread budget from the session AFTER a handoff: a
+                    // handoff to a smaller window is the case that overflows, and the
+                    // budget in hand was computed from the model that just failed.
+                    threadBudgetAfterSwitch: () => resolveThreadBudgetChars({ provider: session.type, model: session.model }),
                     executeTool: async (name, args, ctx) => {
                         const tool = getTool(name);
                         if (!tool)
@@ -1767,6 +2250,19 @@ export class ChatCommand extends BaseCommand {
                     },
                 },
             });
+            // P3 — REMEMBER the worker that actually delivered this task, so the next
+            // turn of the SAME task ("resume", "continue") prefers it instead of
+            // re-deciding from a signal-free word. Only a DELIVERED turn is remembered:
+            // a bounded, cancelled or failed one has taught us nothing about which
+            // model can do this job, and remembering it would propagate the failure.
+            if (!result.cancelled &&
+                !result.generationFailed &&
+                !result.bounded &&
+                !result.termination?.includes('no-capable') &&
+                result.content.trim() &&
+                session.model) {
+                this.taskContinuity.remember(this.lastTaskSignature ?? taskSignature(undefined, undefined), session.type, session.model);
+            }
         }
         catch (err) {
             // The tool loop does not throw on its own; this catches the errors that
@@ -1823,6 +2319,71 @@ export class ChatCommand extends BaseCommand {
                 generationFailed: true,
             };
         }
+        // ── P4 — THE HONEST EXHAUSTION REPORT ────────────────────────────────
+        // A turn that ends without an answer used to deliver a bare line ("the
+        // language model was unavailable") or, worse, a QUESTION that made the user
+        // the retry button. Instead, the user gets the measured facts: which models
+        // were tried and why each did not answer, which targets are unavailable and
+        // the WALL-CLOCK time each frees up, whether this was a routing gap or a real
+        // shortage, and the levers only they can pull — with no request to retry.
+        //
+        // Gated on an actual ATTEMPT (or the loop's evidenced `no-capable-candidate`):
+        // a governance refusal, an admin-budget stop or a bad pin fails with a
+        // healthy pool and a message that is already the right answer, and dressing
+        // those up as exhaustion would be a new lie in place of the old one.
+        if (!result.cancelled &&
+            (result.generationFailed || result.termination === 'no-capable-candidate')) {
+            try {
+                const breadth = modelBreadthReport(modelWalkMark, this.configManager);
+                const seen = new Set(this.turnAttempts.map((a) => `${a.provider}|${a.model}|${a.kind}`));
+                const attempts = [...this.turnAttempts];
+                for (const a of breadth.tried) {
+                    const key = `${a.provider}|${a.model}|${a.kind}`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    attempts.push({
+                        provider: a.provider,
+                        model: a.model,
+                        kind: a.kind,
+                        reason: a.reason || describeFailureKind(a.kind),
+                        ...(a.skipped ? { skipped: true } : {}),
+                    });
+                }
+                if (attempts.length > 0) {
+                    const exclusions = breadth.parked
+                        .filter((r) => r.active)
+                        .map((r) => ({
+                        provider: r.provider,
+                        ...(r.model ? { model: r.model } : {}),
+                        kind: r.kind,
+                        ...(r.expiresAt ? { expiresAt: r.expiresAt } : {}),
+                        ...(r.source ? { source: r.source } : {}),
+                    }));
+                    const reportText = renderExhaustionReport({
+                        attempts,
+                        exclusions,
+                        ...(typeof breadth.poolSize === 'number' ? { poolSize: breadth.poolSize } : {}),
+                        ...(typeof breadth.poolProviders === 'number' ? { poolProviders: breadth.poolProviders } : {}),
+                        task: message,
+                        // The underlying line is kept as the REASON, so a specific,
+                        // actionable cause is never buried by the report.
+                        ...(result.generationFailed && result.content.trim() ? { cause: result.content } : {}),
+                    });
+                    if (reportText) {
+                        result.content = reportText;
+                        recordTraceEvent(chatTraceId, {
+                            kind: 'failover',
+                            summary: `exhaustion report delivered — ${attempts.filter((a) => !a.skipped).length} model(s) tried, ` +
+                                `${exclusions.length} unavailable, eligible pool ${breadth.poolSize ?? '?'}`,
+                        });
+                    }
+                }
+            }
+            catch {
+                // The report is a courtesy — the turn's own failure line still stands.
+            }
+        }
         // Record WHAT HAPPENED, not just "the model answered": a hallucinated
         // "I have sent it" (no tool ran) must be visible as an unverified claim in
         // the Trace tab instead of looking like a real delivery.
@@ -1839,6 +2400,10 @@ export class ChatCommand extends BaseCommand {
             unverifiedEditClaim: result.unverifiedEditClaim,
             undeliveredArtifact: result.undeliveredArtifact,
             unverifiedBuildClaim: result.unverifiedBuildClaim,
+            // Bundle 19/20 — the artifact's own omission, and a file claim no write
+            // backs, both make the turn `incomplete` on the trace (not `answered`).      incompleteArtifactClaim: Boolean(result.artifactIncomplete),
+            unverifiedFileClaim: result.unverifiedFileClaim,
+            artifactShortfall: Boolean(result.artifactShortfall),
         });
         // A cancelled / failed / incomplete turn is NOT a success. `!generationFailed`
         // used to let a cancelled run record `success: true` while its outcome said
@@ -1902,6 +2467,31 @@ export class ChatCommand extends BaseCommand {
             if (result.unverifiedBuildClaim) {
                 logger.warn('   ⚠️  A build command FAILED this turn and no later build succeeded, but the reply reports success — treat the build as UNVERIFIED.');
             }
+            // Bundle 19 — the ARTIFACT-honesty warning. The file this turn wrote says its
+            // own content was omitted, so the prose above describes a document that is not
+            // on disk. The artifact's OWN WORDS are quoted, so the reader sees the evidence
+            // (a specific line the file contains) rather than a verdict they must trust.
+            // Without this the flag only changed the internal verdict; the user still saw
+            // a confident "complete" reply with no sign of the admission inside it.
+            if (result.artifactIncomplete) {
+                logger.warn(`   ⚠️  The file ${result.artifactIncomplete.path} says its own content was omitted ("${result.artifactIncomplete.statement}") — the artifact is INCOMPLETE, whatever the reply above claims.`);
+            }
+            // Bundle 20 — the FILE-CLAIM warning. The reply above says a file was
+            // written and the turn's own record says none was. Found live: a turn wrote
+            // nothing and replied "The guide has been written and saved as GUIDE.md …
+            // contains a full ~5,000-word technical guide" — and the user saw no warning,
+            // because the flag that exists for this failure is gated on the ASK and the
+            // ask was not recognised as a deliverable. This one keys on the CLAIM.
+            if (result.unverifiedFileClaim) {
+                logger.warn('   ⚠️  This reply says a file was written, but NO file was written this turn — treat the deliverable as MISSING, not as done.');
+            }
+            // Bundle 23 (item 13) — the ARTIFACT-VS-ASK warning. The ask named a
+            // magnitude and the file this turn wrote is far short of it; the numbers are
+            // quoted so the reader sees the gap rather than a verdict.
+            if (result.artifactShortfall) {
+                const s = result.artifactShortfall;
+                logger.warn(`   ⚠️  ${s.path} has ~${s.deliveredWords} words, but the request asked for ~${s.targetWords} (${s.source}) — the deliverable is materially SHORT of what was asked.`);
+            }
         }
         catch {
             // Best-effort.
@@ -1968,11 +2558,18 @@ export class ChatCommand extends BaseCommand {
         // affect the answer.
         if (debugLog) {
             const servedModel = this.lastAttempt?.model ?? session.model;
+            // ONE expression for the served pair, used by BOTH the header and the
+            // `turn.end` event — so "what the header says" and "what the events say"
+            // is a single fact rather than two that can drift (the A5/D3 class of
+            // defect, in its last remaining face).
+            const servedProvider = this.lastAttempt?.provider ?? session.type;
             debugLog.backendOf({
-                provider: this.lastAttempt?.provider ?? session.type,
+                provider: servedProvider,
                 ...(servedModel ? { model: servedModel } : {}),
                 transport: result.transport ?? null,
             });
+            const requested = session.model ? `${session.type}/${session.model}` : session.type;
+            const served = servedModel ? `${servedProvider}/${servedModel}` : servedProvider;
             debugLog.event('turn.end', {
                 generationFailed: result.generationFailed === true,
                 cancelled: result.cancelled === true,
@@ -1980,6 +2577,11 @@ export class ChatCommand extends BaseCommand {
                 contentChars: result.content.length,
                 toolCalls: result.toolCalls?.length ?? 0,
                 findings: findings.length,
+                // The pair that answered, and (only when it differs) the pair the turn
+                // asked for — a reader can then tell a straight run from a failover
+                // without cross-referencing the header.
+                served,
+                ...(served === requested ? {} : { requested }),
             });
             const notice = debugLogNotice(ctxOverrides?.debugSurface ?? 'cli-chat', debugLog.write());
             if (notice)
@@ -2014,6 +2616,11 @@ export class ChatCommand extends BaseCommand {
             unfulfilledPromise: result.unfulfilledPromise,
             undeliveredArtifact: result.undeliveredArtifact,
             unverifiedBuildClaim: result.unverifiedBuildClaim,
+            // Bundle 20 — an unbacked file claim (or a self-admitted omission) means
+            // the work did not conclude, so the continuation affordances must appear.
+            incompleteArtifactClaim: Boolean(result.artifactIncomplete),
+            unverifiedFileClaim: result.unverifiedFileClaim,
+            artifactShortfall: Boolean(result.artifactShortfall),
         });
         const chatFollowups = withContinuationFollowups(result.followups, {
             unfinished: !traceOutcomeSucceeded(chatOutcomeForFollowups),
@@ -2030,6 +2637,14 @@ export class ChatCommand extends BaseCommand {
             unfulfilledPromise: result.unfulfilledPromise,
             undeliveredArtifact: result.undeliveredArtifact,
             unverifiedBuildClaim: result.unverifiedBuildClaim,
+            // Bundle 19/20 — carried to the caller so the honesty flags survive the
+            // return boundary instead of only living in the turn report.
+            artifactIncomplete: result.artifactIncomplete,
+            unverifiedFileClaim: result.unverifiedFileClaim,
+            artifactShortfall: result.artifactShortfall,
+            // Item 13 (round 3) — the collectable "fluent, on-length" delivery survives
+            // this boundary too, so `answerOnce` can record it as corpus facts.
+            authoredDeliverable: result.authoredDeliverable,
             // R2 — the transport this turn travelled on (interactive REPL path).
             transport: result.transport,
             // WS1 — the findings this turn recorded, with their verdicts.
@@ -2143,6 +2758,41 @@ export class ChatCommand extends BaseCommand {
                     // refused it). The reason names the provider and the rule.
                     throw new Error(`Governance policy: ${verdict.reason}`);
                 }
+                // ADMIN BUDGET (pinned path). The pin still runs the model the user
+                // chose — this only REFUSES it when the user's own declared budget
+                // (routing.quota window, admin cost cap) is already exceeded, instead
+                // of spending past the control they set in the dashboard. A no-op when
+                // no budget is configured.
+                const budget = adminBudgetVerdict(this.configManager, session.type, { model: session.model });
+                if (!budget.allowed) {
+                    throw new Error(`Admin budget: ${budget.reason}`);
+                }
+            }
+            /**
+             * A2 — REACHABILITY PRE-FLIGHT (pinned path).
+             *
+             * The governance/admin checks above cover POLICY; this covers whether the
+             * pin can work at all. Measured (Run D): `-p openrouter -m
+             * deepseek/deepseek-v4.1-flash` on an unfunded account was sent, and the
+             * operator learned the real cause from a raw 402 body — after a full round
+             * trip, with a live 6-second failure that said nothing about what to do.
+             *
+             * `resolveRoute` refuses that pin, and every one of its callers therefore
+             * does — but this method resolves its own model, so after the first fix the
+             * same run still logged BOTH behaviours: the pipeline refused the pair
+             * before any call ("Refusing to call …") while the chat tool loop sent the
+             * request and got `402 Insufficient credits` back. Same gate, same wording,
+             * same implementation (`strictPinRefusal`) — this is the one seam that was
+             * still missing it.
+             *
+             * Strict mode only, exactly like `resolveRoute`: the refusal sentence says
+             * strict mode forbids substituting, and on a non-strict turn the fallback
+             * walk is the correct repair.
+             */
+            if (!mode.auto && strictModelMode()) {
+                const refusal = strictPinRefusal(session.type, session.model);
+                if (refusal)
+                    throw new Error(refusal);
             }
             const resolveEffectiveModel = (providerType, requested) => {
                 if (requested && requested !== 'default')
@@ -2286,6 +2936,16 @@ export class ChatCommand extends BaseCommand {
                 return await generateWithTransientRetry(() => tryGenerate(session.provider, session.type, session.model), abort, (attempt, err) => logger.warn(`   ⏳ ${session.provider.name} transient failure (attempt ${attempt}) — retrying shortly: ${err instanceof Error ? err.message.split('\n')[0] : String(err)}`));
             }
             catch (err) {
+                // P4 — the model this turn STARTED on failed. Recorded with a human
+                // phrase (never the raw provider text, which is how a JSON quota dump
+                // once reached a user verbatim) so the exhaustion report can name it.
+                const primaryKind = classifyFallbackError(err);
+                this.recordTurnAttempt({
+                    provider: session.type,
+                    model: session.model ?? 'default',
+                    kind: primaryKind,
+                    reason: describeFailureKind(primaryKind),
+                });
                 // Auto mode: fail over across the ranked candidates (never stuck).
                 if (mode.auto) {
                     const firstType = session.type;
@@ -2360,13 +3020,29 @@ export class ChatCommand extends BaseCommand {
                             logger.success(`✅ Auto failover: answered from ${next.provider.name} (${next.model}) after ${firstType} failed`);
                             return resp;
                         }
-                        catch {
+                        catch (nextErr) {
+                            // P4 — record THIS candidate's failure too, so the report lists
+                            // every model the turn was actually served by, in order.
+                            const nextKind = classifyFallbackError(nextErr);
+                            this.recordTurnAttempt({
+                                provider: next.type,
+                                model: next.model ?? 'default',
+                                kind: nextKind,
+                                reason: describeFailureKind(nextKind),
+                            });
                             // Next candidate.
                         }
                     }
                 }
-                else if (isRetryableError(classifyFallbackError(err))) {
+                else if (!strictModelMode() && isRetryableError(classifyFallbackError(err))) {
                     // Non-auto: walk the shared fallback chain (retryable errors only).
+                    //
+                    // Under strict model mode the walk is exactly the substitution the
+                    // user forbade: `strictModelMode()` short-circuits this branch, so a
+                    // pinned model that cannot answer surfaces its own error instead of
+                    // quietly continuing on a provider the user did not choose (A2 — the
+                    // same defect the loop engine had, fixed for dashboard + CLI chat
+                    // here). The `tryGenerate` call above already reports the raw error.
                     // Providers the admin policy rules out are collected here so the
                     // failure can name POLICY as the reason instead of implying the model
                     // was unreachable.
@@ -2391,6 +3067,10 @@ export class ChatCommand extends BaseCommand {
                         catch {
                             // Ordering is an optimization only.
                         }
+                        // The pair the turn was PINNED to. Captured before the walk because
+                        // the walk now installs what it serves (see below), and the warning
+                        // must still name the provider that actually failed.
+                        const pinnedType = session.type;
                         for (const fbType of ordered) {
                             if (fbType === session.type)
                                 continue;
@@ -2428,7 +3108,40 @@ export class ChatCommand extends BaseCommand {
                                 // the dashboard console and the gateway chat engine - looked
                                 // dead.) Undefined = that provider's configured/adapter
                                 // default, which tryGenerate resolves per attempt.
-                                return await tryGenerate(resolved.provider, resolved.type, resolveEffectiveModel(resolved.type, undefined));
+                                const fallbackModel = resolveEffectiveModel(resolved.type, undefined);
+                                const resp = await tryGenerate(resolved.provider, resolved.type, fallbackModel);
+                                // ── The pair that ANSWERED is the pair the turn ran on ───────
+                                // This walk used to serve the fallback and leave `session` still
+                                // naming the provider that had just failed. Everything the turn
+                                // then reported or learned read the WRONG provider against the
+                                // RIGHT model — one interlocking defect with four faces, all
+                                // measured:
+                                //   • the session debug log's `turn.start` named the pinned
+                                //     provider while its own header named the one that served
+                                //     (`backend.provider: deepseek` with `turn.start {"provider":
+                                //     "groq"}` — A5/D3);
+                                //   • `servedRoute()` told the MODEL it was a different model
+                                //     than the one answering;
+                                //   • the response cache stored `provider: "groq"` beside
+                                //     `model: "deepseek-flash"`;
+                                //   • and worst, `recordRegistrySuccess(session.type,
+                                //     session.model)` wrote a PAIR THAT CANNOT EXIST into the
+                                //     model registry as `verified`. That is the self-poisoning:
+                                //     `groq|deepseek-flash` and `groq|gemini-3.1-flash-lite` are
+                                //     both sitting in the live registry as `telemetry`-verified,
+                                //     and because `telemetry` outranks `spot-check` in
+                                //     `preferredModelsFor`, the NEXT groq call picked the bogus
+                                //     id as its adapter default, sent a foreign model name to
+                                //     groq, and 404'd into the same fallback walk — each run
+                                //     making the next one worse.
+                                // The auto branch above has always installed `next`; the pinned
+                                // branch is the one that drifted.
+                                session.type = resolved.type;
+                                session.provider = resolved.provider;
+                                if (fallbackModel)
+                                    session.model = fallbackModel;
+                                logger.warn(`   🔀 ${pinnedType} was unavailable — answered from ${resolved.provider.name} (${fallbackModel ?? 'default'})`);
+                                return resp;
                             }
                             catch {
                                 // Next fallback candidate.
@@ -2642,16 +3355,25 @@ export class ChatCommand extends BaseCommand {
                 .sort()
                 .join(','),
         ]);
-        const decision = withRoutingCache(cacheSignature, 30_000, () => getAutoRouter().resolve('chat', taskText, {
+        const resolveFresh = () => getAutoRouter().resolve('chat', taskText, {
             ...buildAutoResolveOptions(this.configManager, {
                 verbose: envBuff('DEBUG') === 'true',
                 contextHintTokens: opts?.contextHintTokens,
             }),
             circuitBreakerStatus,
             ...(dispatch.taskIntentHint ? { taskIntentHint: dispatch.taskIntentHint } : {}),
-        }, this.configManager));
+        }, this.configManager);
+        const decision = opts?.noCache === true
+            ? resolveFresh()
+            : withRoutingCache(cacheSignature, 30_000, resolveFresh);
         // G5 — record the routing snapshot now (the winner + why), so the reasoning
         // trace for this turn can show the decision instead of a blank column.
+        // P3 — the TASK this turn belongs to, as far as model continuity is
+        // concerned. Kept on the instance because the turn's SUCCESS path (the only
+        // place that knows a model actually DELIVERED) does not hold the routing
+        // decision; intent+complexity is the same key for the original ask and for a
+        // continuation of it, which is exactly the pair that must match.
+        this.lastTaskSignature = taskSignature(dispatch.taskIntentHint ?? decision.taskProfile?.intent, String(decision.complexity));
         this.lastRouteSnapshot = {
             provider: decision.provider,
             model: decision.model,
@@ -2662,6 +3384,9 @@ export class ChatCommand extends BaseCommand {
             // and console can show WHY the pair was chosen, not just which pair.
             agenticCapable: decision.agenticCapable,
             overrideReason: decision.overrideReason,
+            // Bundle 36 — the intent the bandit will bucket this outcome under, so a
+            // later `nuvira rate bad` can correct the EXACT arm (see `verdict-routing.ts`).
+            ...(decision.taskProfile?.intent ? { taskIntent: decision.taskProfile.intent } : {}),
         };
         // Walk the ranked candidates (winner first) and return the first available
         // provider — never a provider that lacks a key or endpoint. Providers that
@@ -2752,9 +3477,15 @@ export class ChatCommand extends BaseCommand {
             crossPipelineMemory: false,
             registryCheck: false,
         });
+        // B2-a — each candidate carries the score OF ITS OWN PAIR, when the pool had
+        // a real measurement for it, plus the scale that score is on. It used to
+        // carry nothing at all and every row was recorded with `decision.score`, so
+        // three different pairs shared one provider-level number (measured live:
+        // `0.43836864406779663` on gemini/gemma-4-26b-a4b-it,
+        // openrouter/cohere/command-r7b-12-2024 and deepseek/deepseek-flash).
         const chatCandidates = [];
         const seenPairs = new Set();
-        const pushCandidate = (prov, mdl) => {
+        const pushCandidate = (prov, mdl, score, scoreBasis) => {
             if (!prov || excluded.has(prov) || registryBlocked.has(prov))
                 return;
             const model = mdl && mdl !== 'default' ? mdl : 'default';
@@ -2772,7 +3503,13 @@ export class ChatCommand extends BaseCommand {
             // already ranks healthy models first, so the parked pick is only ever a
             // last resort that the repair then fixes.
             seenPairs.add(key);
-            chatCandidates.push({ provider: prov, model });
+            chatCandidates.push({
+                provider: prov,
+                model,
+                // Only a labelled measurement travels: an ordering placeholder must not
+                // reach the audit trail as if it described this pair.
+                ...(scoreBasis ? { score, scoreBasis } : {}),
+            });
         };
         // The pool itself is the SAME one the orchestrator/tool/sub-agent path
         // walks: primary → model-first TIERED pool (same model on other providers,
@@ -2780,13 +3517,25 @@ export class ChatCommand extends BaseCommand {
         // reserve) → ranked placeholders → config fallback. Chat used to build a
         // shallower list here, which is why it reached strictly fewer models than
         // the orchestrator could.
+        // P3 — TASK-LEVEL CONTINUITY (RC7). A continuation carries no signal about
+        // its own task, so the router re-decides from scratch and can land on a model
+        // that has never served it (the live `resume` degraded from a working Gemini
+        // model to one that returned nothing). Offer the pair that DID serve this
+        // task FIRST. It is pushed through the same `pushCandidate` gate as every
+        // other candidate, so a dead key, an active exclusion or a registry block
+        // simply drops it and the normal pool is used instead.
+        if (opts?.routingText) {
+            const recalled = this.taskContinuity.recall(this.lastTaskSignature);
+            if (recalled)
+                pushCandidate(recalled.provider, recalled.model);
+        }
         const pool = buildDeepFailoverPool(decision, {
             taskDescription: message,
             complexity: decision.complexity,
             configManager: this.configManager,
         });
         for (const c of pool)
-            pushCandidate(c.provider, c.model);
+            pushCandidate(c.provider, c.model, c.score, c.scoreBasis);
         // Unique provider list (what callers use for their own failover) — derived
         // from the pair list so it stays consistent with what is actually tried.
         const candidates = [...new Set(chatCandidates.map((c) => c.provider))];
@@ -2811,7 +3560,12 @@ export class ChatCommand extends BaseCommand {
                         task: message,
                         verifyOnDemand: isMaxCapability(this.configManager),
                     })).model;
-                    // Record the actually-used route for the dashboard audit trail
+                    // Record the actually-used route for the dashboard audit trail.
+                    // B2-a — the score belongs to THE PAIR THIS ROW NAMES. `decision.score`
+                    // describes the router's own pick; a walked alternate has its own score
+                    // (`candidate.score`, a model-level measurement from the tiered pool) or
+                    // none at all (an ordering placeholder / a recalled pair). Writing the
+                    // decision's number here is what made a walk look like a tie.
                     recordRoutingDecision({
                         source: 'chat',
                         agentType: 'chat',
@@ -2819,7 +3573,9 @@ export class ChatCommand extends BaseCommand {
                         complexity: decision.complexity,
                         provider: candidate.provider,
                         model,
-                        score: decision.score,
+                        ...(candidate.scoreBasis
+                            ? { score: candidate.score, scoreBasis: candidate.scoreBasis }
+                            : {}),
                         agenticCapable: isAgenticCapableModel(model, candidate.provider),
                         overrideReason: decision.overrideReason,
                         ...(opts?.fallbackFrom ? { fallbackFrom: opts.fallbackFrom } : {}),
@@ -2852,6 +3608,10 @@ export class ChatCommand extends BaseCommand {
         // over).
         const usableProvider = [decision.provider, ...decision.ranked.map((r) => r.provider)]
             .find((p) => !isActiveExclusion(p) && !registryBlocked.has(p)) || decision.provider;
+        // B2-a — this row names `decision.model` possibly on a DIFFERENT provider
+        // than the decision's (`usableProvider`), so the decision's composite does
+        // not describe it. The pair was never ranked as a whole; record it bare
+        // rather than attaching a number that belongs to another provider.
         recordRoutingDecision({
             source: 'chat',
             agentType: 'chat',
@@ -2859,7 +3619,6 @@ export class ChatCommand extends BaseCommand {
             complexity: decision.complexity,
             provider: usableProvider,
             model: decision.model,
-            score: decision.score,
             agenticCapable: isAgenticCapableModel(decision.model, usableProvider),
             overrideReason: decision.overrideReason,
             ...(opts?.fallbackFrom ? { fallbackFrom: opts.fallbackFrom } : {}),