agent-nuvira 3.3.13 → 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, strictModelMode } 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, 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.
@@ -489,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
@@ -609,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
@@ -622,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
@@ -667,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,
@@ -675,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),
                 },
             });
         }
@@ -685,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) {
@@ -704,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,
@@ -791,6 +999,40 @@ 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 ──
         // A8 — a pinned concrete provider with `-m auto` is the provider's own auto,
         // not ours. See isAgentAutoRoute.
@@ -890,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)
@@ -1139,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({
@@ -1314,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.
@@ -1369,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
@@ -1390,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.
@@ -1401,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
@@ -1457,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.
@@ -1624,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',
@@ -1634,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, {
@@ -1654,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 {
@@ -1717,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
@@ -1758,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)
@@ -1778,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
@@ -1834,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.
@@ -1850,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
@@ -1913,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.
@@ -1979,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,
@@ -1991,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)
@@ -2025,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),
@@ -2041,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.
@@ -2164,6 +2768,32 @@ export class ChatCommand extends BaseCommand {
                     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')
                     return requested;
@@ -2306,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;
@@ -2380,7 +3020,16 @@ 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.
                         }
                     }
@@ -2418,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;
@@ -2455,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.
@@ -2669,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,
@@ -2689,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
@@ -2779,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';
@@ -2799,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,
@@ -2807,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))];
@@ -2838,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',
@@ -2846,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 } : {}),
@@ -2879,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',
@@ -2886,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 } : {}),