@claudexor/orchestrator 3.17.1 → 3.19.0

package/dist/orchestrator.js

@@ -1,9 +1,11 @@
+import { applyWorkEnvelope, promptWithPointers as renderPromptWithPointers, threadContextPointer, } from "./prompt-framing.js";
+import { requestRefusalFailure } from "./runTerminalResults.js";
 import { delegationBeltFor } from "./delegationBelt.js";
-import { bindProcessingAdmission, processingAdmissionForLease, updateProcessingStreamHold, ProcessingBudgetAdmissionError, } from "./processing-dispatch.js";
+import { bindProcessingAdmission, processingAttemptCostEvidence, processingAdmissionForLease, updateProcessingStreamHold, ProcessingBudgetAdmissionError, } from "./processing-dispatch.js";
 import { cancelledCandidatesResult, emptyCandidateResult, failedCandidatesResult, } from "./candidateTerminals.js";
 import { existsSync } from "node:fs";
-import { effectiveAuthPreference, observeNativeSessionEvent, resumeSessionForProfile, rotateSpecOnTypedLimit, selectedProfileAvailability, } from "./credential-profiles.js";
-import { OrchestratorCredentials, reviewerProfileResolver, rotatedSpecInLaneHome, } from "./orchestrator-credentials.js";
+import { effectiveAuthPreference, observeNativeSessionEvent, resumeSessionForProfile, rotateSpecOnTypedLimit, } from "./credential-profiles.js";
+import { AdmissionProfileProbes, OrchestratorCredentials, reviewerProfileResolver, rotatedSpecInLaneHome, } from "./orchestrator-credentials.js";
 import { accountPoolRows } from "./account-pool.js";
 import { writeRunTelemetryArtifact } from "./runTelemetryWriter.js";
 import { buildFileBackedSynthesisInput, materializeWinnerOutputs, stageFileBackedContext, writeCandidateAttemptArtifacts, } from "./candidateOutputs.js";
@@ -11,18 +13,18 @@ import { processAttemptUsage } from "./attemptUsage.js";
 import { captureDirectoryCandidate, directoryHasOutput, directoryCandidateStable, observeDirectoryPaths, publishDirectoryCandidate, } from "./directoryCandidate.js";
 import { appliedAttemptFacts, assertDelegatedEvidence, isMutatingAccess, outerBoundaryNotice, scopedHarnessHome, } from "./delegatedHome.js";
 import * as AC from "./attemptUsageCost.js";
-import { candidateRoster, candidateStatuses, convergenceOutcomeFacts, isWorkingCandidate, partitionCandidates, toCandidateEvidence, } from "./candidateEvidence.js";
+import { candidateRoster, candidateStatuses, convergenceOutcomeFacts, isWorkingCandidate, partitionCandidates, toCandidateEvidence, unanimousDeclaredFailure, } from "./candidateEvidence.js";
 import { capabilityIntents } from "@claudexor/gateway";
 import { reviewCandidateRuns, resolveEngineReview, unreviewedCandidateEvidence, evaluateUnreviewedConvergence, } from "./candidateReview.js";
 import { join } from "node:path";
 import { finalizePlanRun, runCouncilPlan, writePlanHarnessFailure, } from "./planRun.js";
-import { runPlannerAttempt as executePlannerAttempt, } from "./plannerAttempt.js";
+import { runPlannerAttempt as executePlannerAttempt, plannerAttemptSummary, } from "./plannerAttempt.js";
 import { HarnessRunSpec, MAX_COUNCIL_MEMBERS_DEFAULT, ModeKind as ModeKindSchema, QuotaSnapshot as QuotaSnapshotSchema, isBlocking, makeOutcomeFacts, reviewAllowsApply, workStateVetoes, strictifyOutputSchema, estimateEffectiveAuthRoute, } from "@claudexor/schema";
 import { globalConfigDir, loadConfig } from "@claudexor/config";
 import { prepareRoutedProcessing, processingCostEvidence, prepareReviewerProcessing, } from "./processing-routing.js";
 import { acceptedTryOutput, AccessProfileIncompatibleError, AnswerAssembly, CLAUDEXOR_BROWSER_ARTIFACT_SUBDIR, countsAsAgentProgress, HarnessUnavailableError, summarizeDiffPaths as diffStats, withInactivityWatchdog, } from "@claudexor/core";
 import { assertRouteModelsAllowed, runModelGovernedRoute } from "./modelGovernance.js";
-import { authModeForCredentialRoute, authModeForPreference } from "./auth-route-classification.js";
+import { authModeForCredentialRoute, authModeForPreference, authRouteEvidenceFor, } from "./auth-route-classification.js";
 import { governRouteEffort } from "./effortGovernance.js";
 import { isFullAccess, RequestRequirementsResolver } from "./requestRequirements.js";
 import { activateDelegationParent } from "./delegation-parent-activation.js";
@@ -67,7 +69,7 @@ import { HarnessGateway } from "@claudexor/gateway";
 import { ReadinessLedger, evaluateConvergence, failureSignature, gatesPassed, reviewCandidate, runGates, } from "@claudexor/review";
 import { arbitrate } from "@claudexor/arbitration";
 import { buildSynthesisPlan, decideSynthesis } from "@claudexor/synthesis";
-import { attemptCostEvidence, billingKnowledgeForAuthRoute, attemptUsageCostSettlement, BudgetLedger, isBudgetTerminal, explainRanking, loadHarnessMetrics, promptFingerprint, rankHarnesses, } from "@claudexor/budget";
+import { billingKnowledgeForAuthRoute, attemptUsageCostSettlement, BudgetLedger, isBudgetTerminal, RoutingPreflightError, explainRanking, loadHarnessMetrics, promptFingerprint, rankHarnesses, } from "@claudexor/budget";
 import { readTextSafe, appendLine, assertNoInlineSecretValues, hashJson, newId, noProjectRepoRoot, redactSecrets, safeInvoke, sha256, userConfigDir, } from "@claudexor/util";
 const LABELS = "ABCDEFGHIJ".split("");
 const NO_PROJECT_ROOT = noProjectRepoRoot();
@@ -366,6 +368,7 @@ export class Orchestrator {
         quotaAbsences: () => this.deps.quotaAbsences?.() ?? [],
         credentialUnusable: () => this.deps.credentialUnusable?.() ?? [],
         recordCredentialUnusable: (obs) => this.deps.recordCredentialUnusable?.(obs),
+        preProgressRefusals: () => this.deps.preProgressRefusals,
         authPreferenceForHarness: (repoRoot, harnessId, runPreference) => this.authPreferenceForHarness(repoRoot, harnessId, runPreference),
     });
     /**
@@ -486,9 +489,11 @@ export class Orchestrator {
             dropped.push(detail);
             droppedLanes.push({ harnessId, stage, detail });
         };
-        // One observation set for the whole admission pass, so two lanes cannot be
-        // judged against different vendor epochs.
+        // Initial lane readiness shares one quota observation. Selection and each
+        // physical dispatch still consume the latest exact-profile evidence.
         const vendorQuota = this.credentials.vendorQuotaObservations();
+        // Billing later reuses the probe that admitted each row (#260).
+        const admissionProbes = new AdmissionProfileProbes();
         const liveUnusable = this.deps.credentialUnusable?.() ?? [];
         for (const id of ids) {
             const adapter = this.deps.registry.get(id);
@@ -554,43 +559,20 @@ export class Orchestrator {
             // profile-admitted route joins even an AUTO pool (the run spawns with
             // the profile's transport, so the default store's state is not the
             // routing truth). Capability/manifest gating above still applies.
-            let profileAdmitted = false;
             const profileAdapter = this.deps.registry.get(id);
-            const profileProbe = profileAdapter?.probeCredentialProfile?.bind(profileAdapter);
+            const profileProbe = admissionProbes.record(profileAdapter?.probeCredentialProfile?.bind(profileAdapter));
             const explicitPin = this.credentials.effectiveProfileId(input, id);
-            const model = input.models?.[id] ?? cfgEntry?.default_model ?? null;
             // Pins and bound/pool rows are checked against their own readiness.
-            const rowCandidateIds = [];
-            if (explicitPin) {
-                rowCandidateIds.push(explicitPin);
-            }
-            else if (status.status !== "ok") {
-                const pool = accountPoolRows(this.config(input.repoRoot)?.global.credential_profiles ?? [], id);
-                const bound = input.threadAccountBindings?.[id] ?? null;
-                rowCandidateIds.push(...(bound && pool.some((row) => row.profile_id === bound) ? [bound] : []), ...pool.map((row) => row.profile_id).filter((rowId) => rowId !== bound));
-            }
-            let lastRowVerdict = null;
-            for (const candidateId of rowCandidateIds) {
-                const verdict = await selectedProfileAvailability({
-                    registry: this.config(input.repoRoot)?.global.credential_profiles ?? [],
-                    profileId: candidateId,
-                    harnessId: id,
-                    probe: profileProbe,
-                    // `verification: passed` from the local store only means a login file
-                    // is present. The poller's authenticated vendor call is the only
-                    // liveness evidence; admission must act on it or dispatch may use a revoked token.
-                    quota: vendorQuota,
-                    unusable: liveUnusable,
-                    model,
-                    // Only an explicit/bound route may consume bounded stale LKG evidence.
-                    allowStale: explicitPin !== null || input.threadAccountBindings?.[id] === candidateId,
-                });
-                if (verdict === "available") {
-                    profileAdmitted = true;
-                    break;
-                }
-                lastRowVerdict = verdict;
-            }
+            const rows = await this.credentials.admitRouteRows({
+                input,
+                harnessId: id,
+                defaultReady: status.status === "ok",
+                model: input.models?.[id] ?? cfgEntry?.default_model ?? null,
+                quota: vendorQuota,
+                unusable: liveUnusable,
+                probe: profileProbe,
+            });
+            const profileAdmitted = rows.admitted;
             if (profileAdmitted) {
                 // A valid account row restores manifest intent truth when the default store failed.
                 if (status.status !== "ok") {
@@ -603,14 +585,19 @@ export class Orchestrator {
                 }
             }
             else if (explicitPin) {
-                // An explicit pin that is not ready refuses/drops the lane; a
-                // not-ready UNPINNED row merely leaves the default doctor verdict in
-                // charge (the gates below keep the refusal honest when neither a row
-                // nor a default login exists).
-                const why = `${id} credential profile is not ready: ${lastRowVerdict}`;
+                // An explicit pin that is not ready refuses/drops the lane; not-ready
+                // UNPINNED rows are named below, and the default doctor verdict speaks
+                // only when neither a row nor a default login exists.
+                const why = `${id} credential profile is not ready: ${rows.pinVerdict}`;
                 dropLane(id, "credential", why);
                 continue;
             }
+            // #363: registered rows own this lane, so their observed states — not
+            // the default login's doctor advice — explain why none was admitted.
+            if (rows.unreadyRows && (status.status === "unavailable" || !explicitPool)) {
+                dropLane(id, "credential", rows.unreadyRows);
+                continue;
+            }
             if (status.status === "unavailable" && !profileAdmitted) {
                 const why = `${id} is unavailable${status.reasons.length ? `: ${status.reasons.join("; ")}` : ""}`;
                 dropLane(id, "doctor", why);
@@ -677,7 +664,7 @@ export class Orchestrator {
                     // the default store's sources apply only to profile-less runs.
                     authRouteEstimate: this.credentials.profileAuthRoute(input, id) ??
                         estimateEffectiveAuthRoute(this.authPreferenceForHarness(input.repoRoot, id, input.authPreference), status.authSources),
-                    quotaAdmission: { model: null, profile: null, route: null },
+                    quotaAdmission: { model: null, profile: null, route: null, profileVerification: null },
                     supportsSynthesize: manifest.capabilities.synthesize,
                     supportsInteractive: manifest.capabilities.interactive,
                     liveInput: manifest.capability_profile.live_input,
@@ -722,7 +709,7 @@ export class Orchestrator {
             const model = input.models?.[routed.adapter.id] ?? routed.settings?.defaultModel ?? null;
             let profile;
             try {
-                profile = await this.credentials.preflightProfile(input, routed.adapter.id, model, log, routed.authRouteEstimate);
+                profile = await this.credentials.preflightProfile(input, routed.adapter.id, model, log, routed.authRouteEstimate, admissionProbes);
             }
             catch (err) {
                 // AUTO drops typed lane-local unavailability only when a sibling
@@ -746,8 +733,16 @@ export class Orchestrator {
                             : routed.authRouteEstimate === "local_session"
                                 ? "vendor_native"
                                 : null;
+            const profileVerification = profile
+                ? await this.credentials.selectedProfileBillingVerification(profile, admissionProbes)
+                : null;
             return {
-                prepared: { ...routed, quotaAdmission: { model, profile, route } },
+                prepared: {
+                    ...routed,
+                    quotaAdmission: { model, profile, route, profileVerification },
+                    paidFallback: this.config(input.repoRoot).global.routing.paid_fallback,
+                    billingVerificationForProfile: (actual) => this.credentials.selectedProfileBillingVerification(actual),
+                },
                 refused: null,
             };
         }));
@@ -878,13 +873,14 @@ export class Orchestrator {
                 // engine default. Profile A's cooldown never excludes profile B or the
                 // default on the same harness and route.
                 const credentialSubjectId = r.quotaAdmission.profile?.profile_id ?? null;
-                // QA-034: the typed auth-route evidence (doctor source verification x the
-                // resolved route) is AUTHORITATIVE for billing knowledge in the router —
-                // a VERIFIED native route proves subscription_entitlement, so it survives
+                // QA-034: the typed auth-route evidence (the admitted profile's own
+                // verification, else doctor source verification, x the resolved route)
+                // is AUTHORITATIVE for billing knowledge in the router — a VERIFIED
+                // native route proves subscription_entitlement, so it survives
                 // paid_fallback:never and ranks with a real economy tuple instead of
                 // reading as unknown/paid. Absent (unknown route) falls back to the
                 // metric-derived billingKnowledge below.
-                const authRoute = this.authRouteEvidenceFor(authMode, status?.authSources ?? []);
+                const authRoute = authRouteEvidenceFor(authMode, status?.authSources ?? [], r.quotaAdmission.profileVerification);
                 const processingCost = processingCostEvidence(r.processing, authRoute ? billingKnowledgeForAuthRoute(authRoute) : "unknown", [`harness:${r.adapter.id}`, `profile:${credentialSubjectId ?? "default"}`]);
                 return {
                     harnessId: r.adapter.id,
@@ -984,30 +980,6 @@ export class Orchestrator {
             },
         };
     }
-    /**
-     * Typed auth-route evidence for one candidate (QA-034): the concrete
-     * credential route the resolved auth mode maps to, plus the doctor's
-     * verification for the source that route runs under. `local_session` →
-     * vendor_native + the native/OAuth source verification; `api_key` →
-     * managed_api_key + the key source verification. Unknown route → no evidence
-     * (the router keeps its conservative metric-derived billing). Verification is
-     * the source's typed verdict — never inferred from mere availability.
-     */
-    authRouteEvidenceFor(authMode, sources) {
-        const usable = (s) => s.availability === "available" && s.verification !== "failed";
-        if (authMode === "local_session") {
-            const native = sources.find((s) => usable(s) && (s.source === "native_session" || s.source === "oauth_token_env"));
-            return { route: "vendor_native", verification: native?.verification ?? "not_run" };
-        }
-        if (authMode === "api_key") {
-            const key = sources.find((s) => usable(s) &&
-                (s.source === "api_key_env" ||
-                    s.source === "api_key_flag" ||
-                    s.source === "provider_auth_file"));
-            return { route: "managed_api_key", verification: key?.verification ?? "not_run" };
-        }
-        return undefined;
-    }
     /**
      * Lazy ContextPack: built ONLY for the read-only report modes
      * (explore/plan/readonly_audit) that consume it. Persisted to
@@ -1135,25 +1107,6 @@ export class Orchestrator {
             callerSchema: contract.output_schema ?? null,
         });
     }
-    /**
-     * D-16: apply the resolved WorkReport transport to a built spec — set the
-     * envelope output_schema (constrained/side_tool routes) and APPEND the fenced
-     * metadata instruction (validated routes, e.g. cursor). Mutates the spec in
-     * place and returns the mode the answer unwrap consumes. Called at every
-     * task-producing spec-build site so the transport is never wired one-off.
-     */
-    applyWorkEnvelope(spec, workEnvelope) {
-        if (workEnvelope.outputSchema !== undefined)
-            spec.output_schema = workEnvelope.outputSchema;
-        const instruction = workEnvelope.mode.instruction;
-        if (instruction) {
-            spec.instructions =
-                spec.instructions && spec.instructions.trim()
-                    ? `${spec.instructions}\n\n${instruction}`
-                    : instruction;
-        }
-        return workEnvelope.mode;
-    }
     routeSpecKnobs(routed, contract, overrideModel, effortHint) {
         const s = routed.settings;
         const contractPolicy = contract.external_context.policy;
@@ -1269,6 +1222,8 @@ export class Orchestrator {
                 processing,
                 processingAdmission,
                 physicalDispatchStarted,
+                billingVerificationForProfile: (profile) => this.credentials.selectedProfileBillingVerification(profile),
+                paidFallback: this.config(runInput.repoRoot).global.routing.paid_fallback,
             });
             const result = buildContinuation(req);
             // Disclose on every lane and stamp the turn (INV-137: never silent).
@@ -1286,7 +1241,7 @@ export class Orchestrator {
             const briefPath = join(paths.contextDir, "THREAD.md");
             store.writeText(briefPath, result.packetMarkdown);
             return {
-                pointerLine: `Earlier conversation context for this thread is at: ${briefPath} — read it before answering.`,
+                pointerLine: threadContextPointer(briefPath),
             };
         }
         catch (err) {
@@ -1354,7 +1309,7 @@ export class Orchestrator {
         const sessionFields = runInput
             ? await this.sessionSpecFields(runInput, adapter.id, knobs.model, log, routed.authRouteEstimate, routed.quotaAdmission)
             : undefined;
-        const processingAdmission = processingAdmissionForLease(ledger, processingLease.id, adapter.id, attemptId, processingLease.onDenied);
+        const processingAdmission = processingAdmissionForLease(ledger, processingLease.lease, adapter.id, attemptId, processingLease.onDenied);
         const capturedProcessing = {
             processing_preference: contract.processing_preference,
             processing: knobs.processing?.receipt,
@@ -1362,7 +1317,7 @@ export class Orchestrator {
             processing_allow_paid: knobs.processingAllowPaid,
         };
         const laneContinuity = runInput
-            ? await this.resolveContinuity(runInput, adapter.id, sessionFields?.credential_profile?.profile_id ?? runInput.credentialProfileId ?? null, inPlaceEnvelope && !!sessionFields?.resume_session_id, sessionFields, store, paths, envelope.repo_root, log, capturedProcessing, processingAdmission, () => ledger.markPhysicalDispatchStarted(processingLease.id))
+            ? await this.resolveContinuity(runInput, adapter.id, sessionFields?.credential_profile?.profile_id ?? runInput.credentialProfileId ?? null, inPlaceEnvelope && !!sessionFields?.resume_session_id, sessionFields, store, paths, envelope.repo_root, log, capturedProcessing, processingAdmission, () => ledger.markPhysicalDispatchStarted(processingLease.lease.lease_id))
             : null;
         const artifactRelativeDir = routed.browserRequirement.effective
             ? (wsm.ensureArtifactDirectory(envelope), wsm.ownedArtifactRelativeDirectory(envelope))
@@ -1405,20 +1360,18 @@ export class Orchestrator {
             raw_context_packet: rawContextPacket,
             stream_deltas: streamDeltas,
         });
-        bindProcessingAdmission(spec, ledger, processingLease.id, adapter.id, attemptId, processingLease.onDenied, processingAdmission);
-        const billingInput = runInput ?? { repoRoot: contract.repo.root };
-        // Keep billing route-bound until admission observes the actual prepared
-        // profile. The resolver is evaluated per physical dispatch; preparedCost
-        // gives an actual profile precedence over this pool fallback.
-        spec.extra["routeBillingKnowledge"] = (actual) => actual.credential_profile?.credential_kind === "api_key"
-            ? "metered"
-            : actual.credential_profile
-                ? "subscription_entitlement"
-                : this.routeBillingKnowledge(billingInput, adapter.id);
+        if (runInput)
+            this.credentials.stampProfileSelection(spec, runInput, adapter.id);
+        bindProcessingAdmission(spec, ledger, processingLease.lease, adapter.id, attemptId, processingLease.onDenied, processingAdmission);
+        // Profile-less processing keeps its existing route estimate. Named rows
+        // receive their own verification at the shared physical-dispatch gate.
+        spec.extra["routeBillingKnowledge"] = (actual) => actual.credential_profile
+            ? "unknown"
+            : this.routeBillingKnowledge(runInput ?? { repoRoot: contract.repo.root }, adapter.id);
         if (interaction)
             spec.extra["interactionChannel"] = interaction;
         const workEnvelope = this.workReportEnvelopeFor(routed, contract, Boolean(interaction));
-        const workReportMode = this.applyWorkEnvelope(spec, workEnvelope);
+        const workReportMode = applyWorkEnvelope(spec, workEnvelope);
         const inactivityMs = harnessInactivityTimeoutMs(this.config(contract.repo.root));
         // Named once: the attempt record, the CandidateRun and the terminal gate all
         // read the SAME applied facts rather than three re-derivations. Derived
@@ -1482,6 +1435,8 @@ export class Orchestrator {
                     ? AbortSignal.any([signal, attemptAbort.signal])
                     : attemptAbort.signal;
                 activeSessionId = runSpec.session_id;
+                // #363: bound before the spawn — a credential change mid-try voids it.
+                const refusal = this.credentials.bindPreProgressRefusal(adapter.id, runSpec);
                 const transientStart = telemetry.transientFailures.length;
                 const rateLimitStart = telemetry.rateLimits.length;
                 let rawPatch = null;
@@ -1585,7 +1540,8 @@ export class Orchestrator {
                     // gate and required-actions read a typed category, not a bare boolean.
                     harnessErrored = true;
                     errors.push(safeErrorMessage(err));
-                    if (err instanceof ProcessingBudgetAdmissionError) {
+                    if (err instanceof ProcessingBudgetAdmissionError ||
+                        err instanceof RoutingPreflightError) {
                         processingRefusal = err;
                         break;
                     }
@@ -1595,6 +1551,8 @@ export class Orchestrator {
                 finally {
                     clearFileBackedContext();
                 }
+                if (telemetry.requestRefusal)
+                    break;
                 const newTransients = telemetry.transientFailures.slice(transientStart);
                 // #31: the centralized retry gate reads the classified `retryable` verdict.
                 const sawRetryable = newTransients.some((f) => f.retryable);
@@ -1606,6 +1564,8 @@ export class Orchestrator {
                     ? directoryCapture.files?.noChanges === true
                     : currentDiff.trim().length === 0;
                 const deliverableEmpty = workspaceUnchanged && answer.text().length === 0;
+                const delivered = !harnessErrored && !deliverableEmpty && !signal?.aborted;
+                this.credentials.noteTryServed(refusal, telemetry.outputMarkers, delivered);
                 // W5.4 + A2 failover: a typed-limit hit OR a structural pre-progress
                 // death rebuilds the spec on a NEW session under the next profile.
                 if (harnessErrored && runInput && !signal?.aborted) {
@@ -1617,9 +1577,10 @@ export class Orchestrator {
                         registry: this.config(contract.repo.root)?.global.credential_profiles ?? [],
                         snapshots: this.deps.quotaSnapshots?.() ?? [],
                         probeReadyProfiles: () => this.credentials.readyProfileIdsForRotation(runInput, adapter.id, spec.credential_profile ?? null, triedProfiles, spec.model_hint ?? null),
-                        ...this.credentials.rotationObservations(adapter, spec, newTransients),
+                        ...this.credentials.rotationObservations(adapter, spec, newTransients, refusal),
                         triedProfiles,
                         markers: telemetry.outputMarkers,
+                        requestRefused: Boolean(telemetry.requestRefusal),
                         sawTypedLimit,
                         sawRetryable,
                         attemptErrored: harnessErrored,
@@ -1671,7 +1632,7 @@ export class Orchestrator {
         }
         // A pool-exhausted terminal is rotation's verdict, not the transient
         // machinery's — no `route.transient.exhausted` rides along with it.
-        if (harnessErrored && !poolExhausted && !processingRefusal) {
+        if (harnessErrored && !poolExhausted && !processingRefusal && !telemetry.requestRefusal) {
             emitTransientExhausted((t, p) => log?.emit(t, p), adapter.id, attemptId, telemetry, retryPolicy.maxRetries);
         }
         const attemptStreamEndedMs = Date.now();
@@ -1822,9 +1783,11 @@ export class Orchestrator {
             telemetry,
             ...(secretDiffRefusal ? { secretDiffRefusal } : {}),
             // A5: the typed refusal survives NORMAL attempt finalization (no throw).
-            ...(poolExhausted || processingRefusal
-                ? { declaredFailure: declaredFailure(processingRefusal ?? poolExhausted) }
-                : {}),
+            ...(telemetry.requestRefusal
+                ? { declaredFailure: requestRefusalFailure(telemetry.requestRefusal) }
+                : poolExhausted || processingRefusal
+                    ? { declaredFailure: declaredFailure(processingRefusal ?? poolExhausted) }
+                    : {}),
             outcomeClass: finalized.outcomeClass,
             applied,
         };
@@ -1972,7 +1935,7 @@ export class Orchestrator {
                 attemptId,
                 intent: this.candidateIntent(input),
                 harnessId: routed.adapter.id,
-                cost: attemptCostEvidence(routed.adapter.id, attemptId, this.reservationEstimateUsd(input, i > 0), this.routeBillingKnowledge(input, routed.adapter.id), processingCostEvidence(routed.processing, this.routeBillingKnowledge(input, routed.adapter.id), [`harness:${routed.adapter.id}`])),
+                cost: processingAttemptCostEvidence(routed.adapter.id, attemptId, this.reservationEstimateUsd(input, i > 0), this.routeBillingKnowledge(input, routed.adapter.id, routed), routed.processing),
             });
             log.emit("budget.lease.created", {
                 granted: lease.granted,
@@ -1997,7 +1960,7 @@ export class Orchestrator {
                 routed,
                 attemptId,
                 label: `Candidate ${LABELS[i] ?? i + 1}`,
-                leaseId: lease.lease?.lease_id ?? "",
+                lease: lease.lease,
             });
         }
         const runsBySlot = new Array(slots.length);
@@ -2008,14 +1971,14 @@ export class Orchestrator {
         let candidateContinuationCount = 0;
         const runSlot = async (slot, slotIdx) => {
             if (input.signal?.aborted) {
-                ledger.cancel(slot.leaseId);
+                ledger.cancel(slot.lease.lease_id);
                 return;
             }
             // Leases are granted upfront (before spend exists); a worker still
             // re-checks the circuit breaker so queued slots beyond the parallel wave
             // do not start after earlier candidates already blew the hard cap.
             if (budgetStopped || ledger.tier() === "hard") {
-                ledger.cancel(slot.leaseId);
+                ledger.cancel(slot.lease.lease_id);
                 log.emit("budget.lease.created", {
                     granted: false,
                     reason: "budget exhausted (hard cap reached)",
@@ -2079,7 +2042,7 @@ export class Orchestrator {
                 });
                 harnessHome = this.harnessHomeFor(wsm, envelope, slot.routed, input);
                 const run = await this.runCandidateInEnvelope(slot.routed, envelope, slot.attemptId, slot.label, contract, input.prompt, store, paths, wsm, ledger, {
-                    id: slot.leaseId,
+                    lease: slot.lease,
                     onDenied: (denial) => {
                         budgetStopped = true;
                         budgetDenial ??= denial;
@@ -2089,14 +2052,14 @@ export class Orchestrator {
                     safeInvoke(input.onHarnessEvent, safeEv);
                     log.emit("harness.event", harnessEventPayload(adapter.id, slot.attemptId, safeEv));
                 }, input.signal, downgradeModel ?? undefined, input.effort, this.candidateIntent(input), log, effectiveWeb, this.interactionChannelFor(input, log, runId, taskId, slot.attemptId, adapter.id, slot.routed.supportsInteractive), (streamedUsd) => {
-                    ledger.updateHold(slot.leaseId, streamedUsd);
+                    ledger.updateHold(slot.lease.lease_id, streamedUsd);
                     if (ledger.tier() !== "hard")
                         return false;
                     budgetStopped = true;
                     return true;
                 }, input, requestedSingleCandidate, // W-C4 deltas: single-candidate chat lane only (racing = noise x N)
                 undefined, undefined, harnessHome);
-                ledger.settle(slot.leaseId, attemptUsageCostSettlement(run.cost, run.costEstimated, run.attemptId, run.harnessId, run.telemetry.authMode, run.telemetry.usageCost));
+                ledger.settle(slot.lease.lease_id, attemptUsageCostSettlement(run.cost, run.costEstimated, run.attemptId, run.harnessId, run.telemetry.authMode, run.telemetry.usageCost));
                 log.emit("harness.completed", {
                     harness_id: adapter.id,
                     attempt_id: slot.attemptId,
@@ -2142,7 +2105,7 @@ export class Orchestrator {
                             attemptId: contAttemptId,
                             intent: this.candidateIntent(input),
                             harnessId: adapter.id,
-                            cost: attemptCostEvidence(adapter.id, contAttemptId, this.estimateUsdFloor(input.repoRoot), this.routeBillingKnowledge(input, adapter.id), processingCostEvidence(slot.routed.processing, this.routeBillingKnowledge(input, slot.routed.adapter.id), [`harness:${adapter.id}`])),
+                            cost: processingAttemptCostEvidence(adapter.id, contAttemptId, this.estimateUsdFloor(input.repoRoot), this.routeBillingKnowledge(input, adapter.id, slot.routed), slot.routed.processing),
                         });
                         if (contLease.granted) {
                             candidateContinuationCount += 1; // claim the one-shot only once it launches
@@ -2162,7 +2125,7 @@ export class Orchestrator {
                             const contLeaseId = contLease.lease?.lease_id ?? "";
                             try {
                                 const contRun = await this.runCandidateInEnvelope(slot.routed, envelope, contAttemptId, slot.label, contract, input.prompt, store, paths, wsm, ledger, {
-                                    id: contLeaseId,
+                                    lease: contLease.lease,
                                     onDenied: (denial) => {
                                         budgetStopped = true;
                                         budgetDenial ??= denial;
@@ -2221,7 +2184,7 @@ export class Orchestrator {
             }
             catch (err) {
                 const failureCost = AC.attemptFailureCost(err, "post-stream-error", 0);
-                ledger.settle(slot.leaseId, failureCost.settlement);
+                ledger.settle(slot.lease.lease_id, failureCost.settlement);
                 const message = safeErrorMessage(err);
                 const declared = declaredFailure(err);
                 const infraPhase = envelope === undefined ? "workspace" : "harness";
@@ -2428,7 +2391,7 @@ export class Orchestrator {
                 attemptId: "synth",
                 intent: "synthesize",
                 harnessId: synthRouted.adapter.id,
-                cost: attemptCostEvidence(synthRouted.adapter.id, "synth", this.reservationEstimateUsd(input), this.routeBillingKnowledge(input, synthRouted.adapter.id), processingCostEvidence(synthRouted.processing, this.routeBillingKnowledge(input, synthRouted.adapter.id), [`harness:${synthRouted.adapter.id}`])),
+                cost: processingAttemptCostEvidence(synthRouted.adapter.id, "synth", this.reservationEstimateUsd(input), this.routeBillingKnowledge(input, synthRouted.adapter.id, synthRouted), synthRouted.processing),
             });
             if (lease.granted) {
                 let envelope;
@@ -2455,7 +2418,7 @@ export class Orchestrator {
                     });
                     const synthHome = this.harnessHomeFor(wsm, envelope, synthRouted, input);
                     const run = await this.runCandidateInEnvelope(synthRouted, envelope, "synth", "Synthesis", contract, synthesisInput.prompt, store, paths, wsm, ledger, {
-                        id: lease.lease.lease_id,
+                        lease: lease.lease,
                         onDenied: (denial) => {
                             budgetStopped = true;
                             budgetDenial ??= denial;
@@ -3235,7 +3198,7 @@ export class Orchestrator {
                     attemptId,
                     intent: "repair",
                     harnessId: adapter.id,
-                    cost: attemptCostEvidence(adapter.id, attemptId, this.reservationEstimateUsd(input), this.routeBillingKnowledge(input, adapter.id), processingCostEvidence(routed.processing, this.routeBillingKnowledge(input, routed.adapter.id), [`harness:${adapter.id}`])),
+                    cost: processingAttemptCostEvidence(adapter.id, attemptId, this.reservationEstimateUsd(input), this.routeBillingKnowledge(input, adapter.id, routed), routed.processing),
                 });
                 if (!lease.granted) {
                     exhausted = true;
@@ -3254,7 +3217,7 @@ export class Orchestrator {
                         ...(knobs.ignored.length > 0 ? { ignored_settings: knobs.ignored } : {}),
                     });
                     run = await this.runCandidateInEnvelope(routed, envelope, attemptId, `Attempt ${attempt}`, contract, prompt, store, paths, wsm, ledger, {
-                        id: lease.lease.lease_id,
+                        lease: lease.lease,
                         onDenied: (denial) => {
                             exhausted = true;
                             processingBudgetDenial ??= denial;
@@ -3327,7 +3290,8 @@ export class Orchestrator {
                 // Cancellation/deadline keeps priority over a belt failure finalized concurrently.
                 if (input.signal?.aborted || processingBudgetDenial)
                     break;
-                if (run.telemetry.effortResolution?.resolution === "rejected")
+                if (run.telemetry.requestRefusal ||
+                    run.telemetry.effortResolution?.resolution === "rejected")
                     break;
                 if (delegateFailure.candidateFailureKind(run)) {
                     const failure = delegateFailure.candidateFailureTerminal(run, "convergence");
@@ -3702,6 +3666,7 @@ export class Orchestrator {
                             : (convDeclared?.category ?? "internal"),
                 code: processingBudgetMapping?.code ?? convDeclared?.code ?? null,
                 resetsAt: convDeclared?.resetsAt ?? null,
+                requestRefusal: convDeclared?.requestRefusal,
                 safeMessage: convNeedsDecision
                     ? `review escalated to a human decision after ${attempt} attempt(s)`
                     : facts.reason === "stuck_no_progress"
@@ -3818,17 +3783,17 @@ export class Orchestrator {
     /** Bind private route/session preparation to the planner-attempt owner. */
     plannerAttemptDeps() {
         return {
-            billingKnowledge: (input, harnessId) => this.routeBillingKnowledge(input, harnessId),
+            billingKnowledge: (input, harnessId, routed) => this.routeBillingKnowledge(input, harnessId, routed),
             inactivityTimeoutMs: (repoRoot) => harnessInactivityTimeoutMs(this.config(repoRoot)),
             quotaEventSink: this.deps.quotaEventSink,
-            prepare: async (args) => {
+            prepare: async (args, processingAdmission, physicalDispatchStarted) => {
                 const { input, contract, taskId, runId, log, store, paths, routed, attemptId } = args;
                 const adapter = routed.adapter;
                 const knobs = this.routeSpecKnobs(routed, contract, undefined, input.effort);
                 const effectiveWeb = this.discloseWebUpgrade(log, routed, knobs.webPolicy, attemptId);
                 const sessionFields = await this.sessionSpecFields(input, adapter.id, knobs.model, log, routed.authRouteEstimate, routed.quotaAdmission);
                 const laneContinuity = args.laneRun
-                    ? await this.resolveContinuity(input, adapter.id, sessionFields.credential_profile?.profile_id ?? input.credentialProfileId ?? null, sessionFields.resume_session_id !== null, sessionFields, store, paths, this.execRootOf(input), log)
+                    ? await this.resolveContinuity(input, adapter.id, sessionFields.credential_profile?.profile_id ?? input.credentialProfileId ?? null, sessionFields.resume_session_id !== null, sessionFields, store, paths, this.execRootOf(input), log, this.harnessSpecKnobs(contract, knobs, args.intent), processingAdmission, physicalDispatchStarted)
                     : null;
                 const spec = HarnessRunSpec.parse({
                     session_id: newId("ses"),
@@ -3846,6 +3811,7 @@ export class Orchestrator {
                         ? this.laneHomeEnvFor(input, adapter.id, sessionFields.credential_profile?.profile_id ?? input.credentialProfileId ?? null)
                         : null) ?? args.fallbackHome,
                 });
+                this.credentials.stampProfileSelection(spec, input, adapter.id);
                 const plannerAbort = new AbortController();
                 spec.extra["abortSignal"] = input.signal
                     ? AbortSignal.any([input.signal, plannerAbort.signal])
@@ -3853,7 +3819,7 @@ export class Orchestrator {
                 const planInteraction = this.interactionChannelFor(input, log, runId, taskId, attemptId, adapter.id, routed.supportsInteractive);
                 if (planInteraction)
                     spec.extra["interactionChannel"] = planInteraction;
-                const planWorkMode = this.applyWorkEnvelope(spec, this.workReportEnvelopeFor(routed, contract, Boolean(planInteraction)));
+                const planWorkMode = applyWorkEnvelope(spec, this.workReportEnvelopeFor(routed, contract, Boolean(planInteraction)));
                 return {
                     knobs,
                     effectiveWeb,
@@ -4016,13 +3982,7 @@ export class Orchestrator {
                     // terminal names the refused route and does not read "all planners
                     // failed"; capture the typed denial for the budget classifier.
                     planBudgetDenial ??= outcome.budgetDenial ?? null;
-                    planAttempts.push({
-                        attemptId,
-                        harnessId: outcome.harnessId,
-                        status: outcome.status,
-                        outcomeClass: outcome.outcomeClass,
-                        error: outcome.error,
-                    });
+                    planAttempts.push(plannerAttemptSummary(outcome));
                     break;
                 }
                 if (outcome.telemetry)
@@ -4031,13 +3991,7 @@ export class Orchestrator {
                         harnessId: outcome.harnessId,
                         telemetry: outcome.telemetry,
                     });
-                planAttempts.push({
-                    attemptId,
-                    harnessId: outcome.harnessId,
-                    status: outcome.status,
-                    outcomeClass: outcome.outcomeClass,
-                    error: outcome.error,
-                });
+                planAttempts.push(plannerAttemptSummary(outcome));
                 if (outcome.status !== "success") {
                     if (outcome.telemetry?.effortResolution?.resolution === "rejected")
                         break;
@@ -4162,7 +4116,13 @@ export class Orchestrator {
     quotaSnapshotPreflight() {
         return [...(this.deps.quotaSnapshots?.() ?? [])].map((snapshot) => QuotaSnapshotSchema.parse(snapshot));
     }
-    routeBillingKnowledge(input, harnessId) {
+    routeBillingKnowledge(input, harnessId, routed) {
+        if (routed?.quotaAdmission.profile) {
+            return billingKnowledgeForAuthRoute({
+                route: routed.quotaAdmission.route,
+                verification: routed.quotaAdmission.profileVerification ?? "not_run",
+            });
+        }
         // A selected profile's credential_kind decides billing (round-18 #2).
         const profileRoute = this.credentials.profileAuthRoute(input, harnessId);
         if (profileRoute)
@@ -4194,9 +4154,7 @@ export class Orchestrator {
             // The reducer admits under a finite estimate floor (mirror of the n>1
             // scout reserve) so a subscription route is not refused for lacking a
             // cash quote.
-            attemptCostEvidence(harnessId, attemptId, this.estimateUsdFloor(input.repoRoot), this.routeBillingKnowledge(input, harnessId), processingCostEvidence(routed?.processing, this.routeBillingKnowledge(input, harnessId), [
-                `harness:${harnessId}`,
-            ])),
+            processingAttemptCostEvidence(harnessId, attemptId, this.estimateUsdFloor(input.repoRoot), this.routeBillingKnowledge(input, harnessId, routed), routed?.processing),
             buildSpec: async (routed, homeEnv, prompt, attemptId) => {
                 const knobs = this.routeSpecKnobs(routed, contract, undefined, input.effort);
                 const effectiveWeb = this.discloseWebUpgrade(log, routed, knobs.webPolicy, attemptId);
@@ -4216,10 +4174,11 @@ export class Orchestrator {
                     env_inheritance: envInheritance(this.config(input.repoRoot)),
                     env: homeEnv,
                 });
+                this.credentials.stampProfileSelection(spec, input, routed.adapter.id);
                 // D-16: compile the WorkReport transport onto the reducer spec (the
                 // reducer is non-interactive) so its output is unwrapped + finalized
                 // through the shared attempt contract, not a fourth deliverable predicate.
-                const workReportMode = this.applyWorkEnvelope(spec, this.workReportEnvelopeFor(routed, contract, false));
+                const workReportMode = applyWorkEnvelope(spec, this.workReportEnvelopeFor(routed, contract, false));
                 return {
                     spec,
                     webPolicy: knobs.webPolicy,
@@ -4369,7 +4328,7 @@ export class Orchestrator {
                 // (mirror of the candidate loop): the first top-level scout reserves
                 // without a floor; later scouts and every real Delegate child pass the
                 // repo floor because they overlap an existing family unit.
-                cost: attemptCostEvidence(adapter.id, attemptId, this.reservationEstimateUsd(input, opts.deepScan && idx > 0), this.routeBillingKnowledge(input, adapter.id), processingCostEvidence(routed.processing, this.routeBillingKnowledge(input, routed.adapter.id), [`harness:${adapter.id}`])),
+                cost: processingAttemptCostEvidence(adapter.id, attemptId, this.reservationEstimateUsd(input, opts.deepScan && idx > 0), this.routeBillingKnowledge(input, adapter.id, routed), routed.processing),
             });
             if (!lease.granted) {
                 log.emit("budget.lease.created", {
@@ -4398,6 +4357,10 @@ export class Orchestrator {
                 }
                 return { status: "budget_denied", reason: lease.reason ?? "budget lease denied" };
             }
+            const processingAdmission = processingAdmissionForLease(ledger, lease.lease, adapter.id, attemptId, (denial) => {
+                budgetStopped = true;
+                budgetDenial ??= denial;
+            });
             // As with planners, the granted lease owns profile/continuity/spec
             // preparation. Contain a pre-stream rejection as this attempt's failure;
             // parallel siblings can then finish before the shared HOME is disposed.
@@ -4418,17 +4381,11 @@ export class Orchestrator {
                 // scouts are excluded from laneRun); native resume is available only when
                 // this slot was granted the lane's recorded session.
                 const laneContinuity = laneRun
-                    ? await this.resolveContinuity(input, adapter.id, sessionFields.credential_profile?.profile_id ?? input.credentialProfileId ?? null, grantResume, sessionFields, store, paths, this.execRootOf(input), log)
+                    ? await this.resolveContinuity(input, adapter.id, sessionFields.credential_profile?.profile_id ?? input.credentialProfileId ?? null, grantResume, sessionFields, store, paths, this.execRootOf(input), log, this.harnessSpecKnobs(contract, knobs, opts.intent), processingAdmission, () => ledger.markPhysicalDispatchStarted(lease.lease.lease_id))
                     : null;
                 // D-16d: the continuation packet pointer rides after the lane pointer so
                 // the fresh session is re-grounded in the exhausted attempt's work.
-                const promptWithPointers = [
-                    explorerPrompt,
-                    laneContinuity?.pointerLine,
-                    continuationPointer,
-                ]
-                    .filter((p) => Boolean(p))
-                    .join("\n\n");
+                const promptWithPointers = renderPromptWithPointers(explorerPrompt, laneContinuity?.pointerLine, continuationPointer);
                 const spec = HarnessRunSpec.parse({
                     session_id: newId("ses"),
                     intent: opts.intent,
@@ -4451,6 +4408,7 @@ export class Orchestrator {
                         ? this.laneHomeEnvFor(input, adapter.id, sessionFields.credential_profile?.profile_id ?? input.credentialProfileId ?? null)
                         : null) ?? roHome.env,
                 });
+                this.credentials.stampProfileSelection(spec, input, adapter.id);
                 const reportAbort = new AbortController();
                 spec.extra["abortSignal"] = input.signal
                     ? AbortSignal.any([input.signal, reportAbort.signal])
@@ -4460,7 +4418,7 @@ export class Orchestrator {
                     spec.extra["interactionChannel"] = reportInteraction;
                 // D-16: compile the WorkReport envelope for the read-only lane.
                 const readonlyWorkEnvelope = this.workReportEnvelopeFor(routed, contract, Boolean(reportInteraction));
-                const readonlyWorkMode = this.applyWorkEnvelope(spec, readonlyWorkEnvelope);
+                const readonlyWorkMode = applyWorkEnvelope(spec, readonlyWorkEnvelope);
                 const attemptEventsPath = join(paths.attemptsDir, attemptId, "events.jsonl");
                 const answer = new AnswerAssembly();
                 const telemetry = createAttemptTelemetry(knobs.webPolicy, contract.external_context.web_required, effectiveWeb, [], 
@@ -4482,7 +4440,7 @@ export class Orchestrator {
                 const message = `read-only attempt setup failed: ${safeErrorMessage(preparation.error)}`;
                 AC.settleGrantedAttemptLease({
                     ledger,
-                    leaseId: lease.lease?.lease_id ?? "",
+                    leaseId: lease.lease.lease_id,
                     attemptId,
                     harnessId: adapter.id,
                     costUsd: 0,
@@ -4515,10 +4473,7 @@ export class Orchestrator {
             const { knobs, spec: preparedSpec, reportAbort, reportInteraction, readonlyWorkMode, attemptEventsPath, telemetry, } = preparation.value;
             let { answer } = preparation.value;
             let spec = preparedSpec;
-            bindProcessingAdmission(spec, ledger, lease.lease.lease_id, adapter.id, attemptId, (denial) => {
-                budgetStopped = true;
-                budgetDenial ??= denial;
-            });
+            bindProcessingAdmission(spec, ledger, lease.lease, adapter.id, attemptId, undefined, processingAdmission);
             const retryPolicy = transientRetryPolicy(this.config(input.repoRoot));
             let activeSessionId = spec.session_id;
             const live = liveAttempt(input, routed, paths, contract, attemptId, () => activeSessionId);
@@ -4553,6 +4508,8 @@ export class Orchestrator {
                             extra: { ...spec.extra },
                         });
                     activeSessionId = runSpec.session_id;
+                    // #363: bound before the spawn — a credential change mid-try voids it.
+                    const refusal = this.credentials.bindPreProgressRefusal(adapter.id, runSpec);
                     const transientStart = telemetry.transientFailures.length;
                     const rateLimitStart = telemetry.rateLimits.length;
                     log.emit("harness.started", {
@@ -4618,7 +4575,8 @@ export class Orchestrator {
                     }
                     catch (err) {
                         harnessError = safeErrorMessage(err);
-                        if (err instanceof ProcessingBudgetAdmissionError) {
+                        if (err instanceof ProcessingBudgetAdmissionError ||
+                            err instanceof RoutingPreflightError) {
                             processingRefusal = err;
                             break;
                         }
@@ -4628,10 +4586,14 @@ export class Orchestrator {
                     }
                     if (streamBudgetDenied)
                         break;
+                    if (telemetry.requestRefusal)
+                        break;
                     const newTransients = telemetry.transientFailures.slice(transientStart);
                     const sawRetryable = newTransients.some((f) => f.retryable);
                     const sawTypedLimit = telemetry.rateLimits.length > rateLimitStart;
                     const reportSoFar = answer.text();
+                    const delivered = !harnessError && reportSoFar.length > 0 && !input.signal?.aborted;
+                    this.credentials.noteTryServed(refusal, telemetry.outputMarkers, delivered);
                     // W5.4 + A2 reactive failover, READ-ONLY lane (same contract as the
                     // candidate lane: typed limit or structural pre-progress death).
                     if (harnessError && !input.signal?.aborted) {
@@ -4643,9 +4605,10 @@ export class Orchestrator {
                             registry: this.config(input.repoRoot)?.global.credential_profiles ?? [],
                             snapshots: this.deps.quotaSnapshots?.() ?? [],
                             probeReadyProfiles: () => this.credentials.readyProfileIdsForRotation(input, adapter.id, spec.credential_profile ?? null, triedProfiles, spec.model_hint ?? null),
-                            ...this.credentials.rotationObservations(adapter, spec, newTransients),
+                            ...this.credentials.rotationObservations(adapter, spec, newTransients, refusal),
                             triedProfiles,
                             markers: telemetry.outputMarkers,
+                            requestRefused: Boolean(telemetry.requestRefusal),
                             sawTypedLimit,
                             sawRetryable,
                             attemptErrored: harnessError !== null,
@@ -4694,7 +4657,7 @@ export class Orchestrator {
                 input.signal?.removeEventListener("abort", onAbort);
                 AC.settleGrantedAttemptLease({
                     ledger,
-                    leaseId: lease.lease?.lease_id ?? "",
+                    leaseId: lease.lease.lease_id,
                     attemptId,
                     harnessId: adapter.id,
                     costUsd: cost,
@@ -4704,7 +4667,7 @@ export class Orchestrator {
                     preStreamFailureSource: "readonly-pre-stream",
                 });
             }
-            if (harnessError && !poolExhausted && !processingRefusal) {
+            if (harnessError && !poolExhausted && !processingRefusal && !telemetry.requestRefusal) {
                 emitTransientExhausted((t, p) => log.emit(t, p), adapter.id, attemptId, telemetry, retryPolicy.maxRetries);
             }
             attemptTelemetries.push({ attemptId, harnessId: adapter.id, telemetry });
@@ -4765,9 +4728,11 @@ export class Orchestrator {
                     report,
                     error: harnessError,
                     telemetry,
-                    ...(poolExhausted || processingRefusal
-                        ? { declaredFailure: declaredFailure(processingRefusal ?? poolExhausted) }
-                        : {}),
+                    ...(telemetry.requestRefusal
+                        ? { declaredFailure: requestRefusalFailure(telemetry.requestRefusal) }
+                        : poolExhausted || processingRefusal
+                            ? { declaredFailure: declaredFailure(processingRefusal ?? poolExhausted) }
+                            : {}),
                 });
                 if (opts.deepScan) {
                     store.writeText(join(paths.findingsDir, `${attemptId}-error.md`), `# Explorer ${attemptId} failed\n\n${harnessError}\n`);
@@ -4882,6 +4847,7 @@ export class Orchestrator {
                     const firstModel = contract.routing_models[routed.adapter.id] ?? routed.settings?.defaultModel ?? null;
                     if (last &&
                         last.status === "failed" &&
+                        !last.telemetry.requestRefusal &&
                         fallbackModel &&
                         fallbackModel !== firstModel &&
                         !budgetStopped &&
@@ -5008,6 +4974,7 @@ export class Orchestrator {
                     eventRefs: roEventRefs,
                     runDir: paths.root,
                     resetsAt: roDeclared?.resetsAt ?? null,
+                    requestRefusal: roDeclared?.requestRefusal,
                     vendorFailure: attemptVendorFailure(attemptTelemetries, last?.attemptId),
                     nextActions: harnessFailureNextActions(roCategory),
                 });
@@ -5068,10 +5035,7 @@ export class Orchestrator {
         const succeeded = succeededReadonly;
         if (opts.deepScan && succeeded.length === 0) {
             const blocked = attempts.some((a) => a.status === "blocked");
-            // QA-050/QA-019: an all-denied scan (finite-zero, or every scout refused
-            // before spawn) is a BUDGET failure, not harness_error — route it through
-            // the shared classifier. Only a pure-denial scan (no scout actually errored
-            // in the harness) qualifies, so a real explorer failure is never masked.
+            // QA-050/QA-019: only a pure-denial scan may claim a budget failure.
             const scanBudgetMapping = budgetStopped && !blocked && attempts.every((a) => a.budgetDenied === true)
                 ? classifyBudgetFailure({ denial: budgetDenial, terminal: ledger.terminal() })
                 : null;
@@ -5093,12 +5057,15 @@ export class Orchestrator {
                 }));
             }
             else {
-                // #31: classify the scout failures; keep the scan-specific width hint but
-                // drop the unconditional auth line unless the cause was a real auth failure.
+                // Mixed causes stay generic; only unanimous evidence may name the scan's cause.
+                const declared = blocked ? null : unanimousDeclaredFailure(attempts);
                 const scanCategory = dominantHarnessFailureCategory(attemptTelemetries.flatMap((a) => a.telemetry.transientFailures));
                 writeFailure(store, paths, {
                     phase: "harness",
-                    category: blocked ? "policy" : "harness_error",
+                    category: blocked ? "policy" : (declared?.category ?? "harness_error"),
+                    code: declared?.code,
+                    resetsAt: declared?.resetsAt,
+                    requestRefusal: declared?.requestRefusal,
                     safeMessage: message || "all explorers failed",
                     eventRefs: attempts.map((a) => `attempts/${a.attemptId}/events.jsonl`),
                     runDir: paths.root,
@@ -5109,10 +5076,7 @@ export class Orchestrator {
                     ],
                 });
             }
-            // QA-036: with ZERO successful explorers there is no synthesizable
-            // deliverable, so a blocked scan can no longer read as a succeeded
-            // "needs review" run (exit 0). An empty scan is a failure whether the
-            // explorers were blocked or errored.
+            // QA-036: no successful explorer means no synthesizable deliverable.
             store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${opts.mode})\n\n- Lifecycle: ${scanFailFacts.lifecycle}${scanFailFacts.reason ? ` (${scanFailFacts.reason})` : ""}\n\n${message}\n`);
             log.emit("output.ready", { kind: "summary", path: "final/summary.md", state: "diagnostic" });
             log.emit("run.failed", {