@lsctech/polaris 0.4.9 → 0.5.0

package/dist/loop/adapters/terminal-cli.js

@@ -46,6 +46,71 @@ function resolveCommand(cmd) {
         return false;
     }
 }
+function isQuotaExhaustedSignal(...parts) {
+    const text = parts.filter((value) => typeof value === "string" && value.length > 0).join("\n").toLowerCase();
+    if (!text)
+        return false;
+    return (text.includes("quota") ||
+        text.includes("rate limit") ||
+        text.includes("429") ||
+        text.includes("resource exhausted") ||
+        text.includes("insufficient_quota"));
+}
+function hasWorkerExecutionEvidence(packet, resultFilePath) {
+    if (resultFilePath && node_fs_1.default.existsSync(resultFilePath))
+        return true;
+    if (!packet.telemetry_file || !packet.active_child || !node_fs_1.default.existsSync(packet.telemetry_file))
+        return false;
+    try {
+        const telemetry = node_fs_1.default.readFileSync(packet.telemetry_file, "utf-8").trim();
+        if (!telemetry)
+            return false;
+        const lines = telemetry.split("\n");
+        const packetDispatchId = packet.dispatch_id;
+        // Scan backwards: when both the packet and the parsed event carry a dispatch_id,
+        // use that as the primary scope gate so stale events from a previous attempt are
+        // never attributed to the current dispatch.  Fall back to the child-dispatched
+        // boundary for older telemetry that lacks dispatch_id on individual events.
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i]?.trim();
+            if (!line)
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.child_id !== packet.active_child)
+                    continue;
+                if (parsed.event === "worker-acknowledged" ||
+                    parsed.event === "worker-heartbeat" ||
+                    parsed.event === "worker-result") {
+                    const eventDispatchId = parsed.dispatch_id;
+                    if (packetDispatchId && eventDispatchId) {
+                        // Primary gate: dispatch_id available on both sides — match determines
+                        // whether this event belongs to the current dispatch.
+                        if (eventDispatchId === packetDispatchId)
+                            return true;
+                        // Mismatch — event belongs to a different dispatch; keep scanning.
+                        continue;
+                    }
+                    // Fallback: dispatch_id not available on one or both sides — accept the
+                    // event as evidence for the current dispatch (scoped by the
+                    // child-dispatched boundary below).
+                    return true;
+                }
+                // Boundary fallback: stop at the child-dispatched event so events from a
+                // prior attempt are not counted when dispatch_id matching is unavailable.
+                if (parsed.event === "child-dispatched")
+                    break;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
 class TerminalCliAdapter {
     config;
     name = 'terminal-cli';
@@ -102,6 +167,8 @@ class TerminalCliAdapter {
     }
     async dispatch(packet, options) {
         const primaryProvider = options.provider || "terminal-cli";
+        const routerEvidence = options.routerDecision;
+        const providerAttempts = [];
         if ((0, worker_packet_js_1.isWorkerPacket)(packet) && packet.worker_role === "impl") {
             const allowed = Array.isArray(packet.instructions?.allowed_scope) ? packet.instructions.allowed_scope : [];
             if (allowed.length === 0) {
@@ -119,6 +186,20 @@ class TerminalCliAdapter {
                     }),
                     stderr: blockedMsg,
                     pre_dispatch_failure: true,
+                    failure_origin: "provider-launch",
+                    failure_category: "launch-error",
+                    fallback_eligible: false,
+                    router_evidence: routerEvidence,
+                    provider_attempts: [
+                        {
+                            provider: primaryProvider,
+                            failure_origin: "provider-launch",
+                            failure_category: "launch-error",
+                            pre_dispatch_failure: true,
+                            fallback_eligible: false,
+                            message: blockedMsg,
+                        },
+                    ],
                 };
             }
         }
@@ -132,11 +213,15 @@ class TerminalCliAdapter {
         const policyProviders = (canFallback && Array.isArray(workerPolicy?.providers))
             ? workerPolicy.providers
             : [];
+        const routerProviders = canFallback && Array.isArray(routerEvidence?.providersTried)
+            ? routerEvidence.providersTried
+            : [];
+        const fallbackOrder = routerProviders.length > 0 ? routerProviders : policyProviders;
         const providersToTry = [
             { name: primaryProvider, cfg: primaryCfg, isPrimary: true },
         ];
         if (canFallback) {
-            for (const p of policyProviders) {
+            for (const p of fallbackOrder) {
                 if (p !== primaryProvider && p in (this.config.providers ?? {})) {
                     try {
                         providersToTry.push({ name: p, cfg: this.getProvider(p), isPrimary: false });
@@ -167,12 +252,30 @@ class TerminalCliAdapter {
                         provider_used: provider,
                         command_run: provider,
                         stderr: err instanceof Error ? err.message : String(err),
+                        pre_dispatch_failure: true,
+                        failure_origin: "provider-launch",
+                        failure_category: "launch-error",
+                        fallback_eligible: true,
+                        router_evidence: routerEvidence,
                     };
+                    providerAttempts.push({
+                        provider,
+                        failure_origin: "provider-launch",
+                        failure_category: "launch-error",
+                        pre_dispatch_failure: true,
+                        fallback_eligible: true,
+                        message: lastResult.stderr,
+                    });
                     continue;
                 }
                 const commandLine = formatCommandLine(command, args);
                 if (options.dryRun) {
-                    return this.dryRun(provider, command, args, commandLine, packet, packetFile, workerPrompt);
+                    const dryRun = this.dryRun(provider, command, args, commandLine, packet, packetFile, workerPrompt);
+                    return {
+                        ...dryRun,
+                        router_evidence: routerEvidence,
+                        provider_attempts: providerAttempts,
+                    };
                 }
                 if (!resolveCommand(command)) {
                     lastResult = {
@@ -181,28 +284,108 @@ class TerminalCliAdapter {
                         command_run: commandLine,
                         stderr: `Provider command "${command}" not found on PATH. ` +
                             `Install it or update the "command" field for provider "${provider}" in polaris.config.json.`,
+                        pre_dispatch_failure: true,
+                        failure_origin: "provider-launch",
+                        failure_category: "provider-unavailable",
+                        fallback_eligible: true,
+                        router_evidence: routerEvidence,
+                    };
+                    providerAttempts.push({
+                        provider,
+                        failure_origin: "provider-launch",
+                        failure_category: "provider-unavailable",
+                        pre_dispatch_failure: true,
+                        fallback_eligible: true,
+                        message: lastResult.stderr,
+                    });
+                    continue;
+                }
+                let result;
+                try {
+                    result = await this.runProcess(command, args, commandLine, packet, packetFile, provider, workerPrompt);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    lastResult = {
+                        exit_code: 1,
+                        provider_used: provider,
+                        command_run: commandLine,
+                        stderr: message,
+                        pre_dispatch_failure: true,
+                        failure_origin: "provider-launch",
+                        failure_category: "provider-unavailable",
+                        fallback_eligible: true,
+                        router_evidence: routerEvidence,
                     };
+                    providerAttempts.push({
+                        provider,
+                        failure_origin: "provider-launch",
+                        failure_category: "provider-unavailable",
+                        pre_dispatch_failure: true,
+                        fallback_eligible: true,
+                        message,
+                    });
                     continue;
                 }
-                const result = await this.runProcess(command, args, commandLine, packet, packetFile, provider, workerPrompt);
                 // Worker succeeded — return immediately.
                 if (result.exit_code === 0) {
-                    return result;
+                    return {
+                        ...result,
+                        router_evidence: routerEvidence,
+                        provider_attempts: providerAttempts,
+                    };
                 }
-                // If the worker wrote a result file it actually ran (and failed) — don't
-                // retry with another provider; that would double-dispatch the same child.
                 const resultFilePath = (0, worker_packet_js_1.isWorkerPacket)(packet) ? packet.result_file_contract?.result_file : undefined;
-                if (resultFilePath && node_fs_1.default.existsSync(resultFilePath)) {
-                    return result;
+                const workerStarted = hasWorkerExecutionEvidence(packet, resultFilePath);
+                if (workerStarted) {
+                    return {
+                        ...result,
+                        failure_origin: "worker-execution",
+                        failure_category: "worker-failure",
+                        fallback_eligible: false,
+                        router_evidence: routerEvidence,
+                        provider_attempts: providerAttempts,
+                    };
                 }
-                // Worker did not start (wrong args, command not found, etc.) — try next.
-                lastResult = result;
+                const category = isQuotaExhaustedSignal(result.stderr, result.stdout, result.summary)
+                    ? "quota-exhausted"
+                    : "provider-unavailable";
+                const classified = {
+                    ...result,
+                    pre_dispatch_failure: true,
+                    failure_origin: "provider-launch",
+                    failure_category: category,
+                    fallback_eligible: true,
+                    router_evidence: routerEvidence,
+                };
+                providerAttempts.push({
+                    provider,
+                    failure_origin: "provider-launch",
+                    failure_category: category,
+                    pre_dispatch_failure: true,
+                    fallback_eligible: true,
+                    message: result.stderr ?? result.summary,
+                });
+                lastResult = classified;
             }
-            return lastResult ?? {
+            const exhausted = lastResult ?? {
                 exit_code: 1,
                 provider_used: primaryProvider,
                 command_run: '',
                 stderr: 'All configured providers exhausted without starting a worker',
+                pre_dispatch_failure: true,
+                failure_origin: "provider-launch",
+                failure_category: "provider-unavailable",
+                fallback_eligible: false,
+                router_evidence: routerEvidence,
+                provider_attempts: providerAttempts,
+            };
+            return {
+                ...exhausted,
+                // All providers have been exhausted — no further fallback is possible.
+                fallback_eligible: false,
+                router_evidence: exhausted.router_evidence ?? routerEvidence,
+                provider_attempts: exhausted.provider_attempts ?? providerAttempts,
             };
         }
         finally {

package/dist/loop/checkpoint.js

@@ -269,6 +269,46 @@ function validateState(state) {
             }
         }
     }
+    if ("worker_pool_state" in s && s["worker_pool_state"] !== undefined) {
+        if (typeof s["worker_pool_state"] !== "object" || s["worker_pool_state"] === null || Array.isArray(s["worker_pool_state"])) {
+            errors.push("worker_pool_state must be an object");
+        }
+        else {
+            const pool = s["worker_pool_state"];
+            if (typeof pool["max_concurrent"] !== "number" ||
+                !Number.isInteger(pool["max_concurrent"]) ||
+                pool["max_concurrent"] < 1) {
+                errors.push("worker_pool_state.max_concurrent must be a positive integer");
+            }
+            if (!Array.isArray(pool["slot_claims"])) {
+                errors.push("worker_pool_state.slot_claims must be an array");
+            }
+            else {
+                for (const [index, claim] of pool["slot_claims"].entries()) {
+                    if (typeof claim !== "object" || claim === null || Array.isArray(claim)) {
+                        errors.push(`worker_pool_state.slot_claims[${index}] must be an object`);
+                        continue;
+                    }
+                    const typed = claim;
+                    if (typeof typed["child_id"] !== "string" || typed["child_id"].trim().length === 0) {
+                        errors.push(`worker_pool_state.slot_claims[${index}].child_id must be a non-empty string`);
+                    }
+                    if (typed["provider"] !== null && typeof typed["provider"] !== "string") {
+                        errors.push(`worker_pool_state.slot_claims[${index}].provider must be a string or null`);
+                    }
+                    if (typeof typed["claimed_at"] !== "string") {
+                        errors.push(`worker_pool_state.slot_claims[${index}].claimed_at must be a string`);
+                    }
+                    if (typeof typed["expires_at"] !== "string") {
+                        errors.push(`worker_pool_state.slot_claims[${index}].expires_at must be a string`);
+                    }
+                    if (typeof typed["selection_reason"] !== "string") {
+                        errors.push(`worker_pool_state.slot_claims[${index}].selection_reason must be a string`);
+                    }
+                }
+            }
+        }
+    }
     return errors;
 }
 function writeStateAtomic(stateFile, state) {

package/dist/loop/dispatch.js

@@ -15,6 +15,7 @@ const body_parser_js_1 = require("./body-parser.js");
 const loader_js_1 = require("../config/loader.js");
 const store_js_1 = require("../cluster-state/store.js");
 const worker_prompt_js_1 = require("./worker-prompt.js");
+const index_js_1 = require("./router/index.js");
 function resolveSimplicityMode(state, config) {
     if (state.simplicity_bypass)
         return "off";
@@ -23,7 +24,7 @@ function resolveSimplicityMode(state, config) {
 const dispatch_boundary_js_1 = require("./dispatch-boundary.js");
 const run_bootstrap_js_1 = require("./run-bootstrap.js");
 const ledger_js_1 = require("./ledger.js");
-const index_js_1 = require("../tracker/index.js");
+const index_js_2 = require("../tracker/index.js");
 const lifecycle_transition_js_1 = require("../tracker/lifecycle-transition.js");
 const CLAIM_TTL_MS = 30 * 60 * 1000;
 /**
@@ -46,18 +47,51 @@ function roleContextToExecutionRole(role) {
             return "worker";
     }
 }
-function resolveProviderAndMode(options, role, config) {
-    const defaultAdapter = "terminal-cli";
-    if (options.provider) {
-        return {
-            provider: options.provider,
-            mode: "direct-worker",
-            adapter: defaultAdapter,
-            selectionReason: "cli-provider-override",
-            overrideSource: "dispatch-flag",
-            providersTried: [options.provider],
-        };
+function roleContextToTaskType(roleContext) {
+    switch (roleContext?.role) {
+        case "analyst":
+            return "analyze";
+        case "librarian":
+            return "docs";
+        case "foreman":
+            return "startup";
+        case "worker":
+        default:
+            return "impl";
     }
+}
+function requiredCapabilitiesForTask(taskType) {
+    switch (taskType) {
+        case "startup":
+            return ["orchestration"];
+        case "analyze":
+            return ["analysis"];
+        case "impl":
+            return ["implementation"];
+        case "repair":
+            return ["repair"];
+        case "docs":
+            return ["docs"];
+        case "finalize":
+            return ["finalization"];
+        default:
+            return [];
+    }
+}
+function collectActiveProviderSlots(state) {
+    const counts = {};
+    for (const meta of Object.values(state.open_children_meta ?? {})) {
+        const dispatch = meta?.dispatch_record;
+        if (!dispatch?.provider)
+            continue;
+        if (dispatch.status !== "dispatched")
+            continue;
+        counts[dispatch.provider] = (counts[dispatch.provider] ?? 0) + 1;
+    }
+    return counts;
+}
+function resolveProviderAndMode(options, role, config, routerContext) {
+    const defaultAdapter = "terminal-cli";
     // Only catch config-load failures; policy violations must propagate to the caller.
     let loaded;
     let adapter = defaultAdapter;
@@ -78,6 +112,64 @@ function resolveProviderAndMode(options, role, config) {
         };
     }
     const exec = loaded.execution;
+    const providerRegistry = exec?.routerPolicy?.providerRegistry ?? {};
+    const compatibilityMode = Object.keys(providerRegistry).length === 0;
+    if (compatibilityMode) {
+        return resolveProviderAndModeLegacy(options, role, adapter, exec);
+    }
+    const decision = (0, index_js_1.decideWorkerRoute)({
+        role,
+        taskType: routerContext?.taskType ?? "impl",
+        adapter,
+        providerOverride: options.provider,
+        providers: Object.keys(exec?.providers ?? {}),
+        rotation: exec?.rotation ?? [],
+        rolePolicy: exec?.providerPolicy?.[role],
+        roleConfiguredProvider: exec?.roles?.[role]?.provider,
+        routerPolicy: exec?.routerPolicy,
+        constraints: {
+            minTrustTier: routerContext?.minTrustTier,
+            maxCostTier: routerContext?.maxCostTier,
+            disallowedQuotaPolicies: routerContext?.disallowedQuotaPolicies,
+            requiredCapabilities: routerContext?.requiredCapabilities,
+        },
+        runtime: {
+            activeSlotsByProvider: routerContext?.activeSlotsByProvider,
+            quotaAvailableByProvider: routerContext?.quotaAvailableByProvider,
+        },
+        compatibilityMode: false,
+    });
+    return {
+        provider: decision.selectedProvider,
+        mode: decision.mode,
+        adapter,
+        selectionReason: decision.selectionReason,
+        overrideSource: options.provider ? "dispatch-flag" : undefined,
+        providersTried: decision.providersTried,
+        exhaustedReason: decision.exhaustedReason,
+        routerEvidence: decision,
+        routerContextSnapshot: {
+            taskType: routerContext?.taskType ?? "impl",
+            requiredCapabilities: routerContext?.requiredCapabilities,
+            minTrustTier: routerContext?.minTrustTier,
+            maxCostTier: routerContext?.maxCostTier,
+            disallowedQuotaPolicies: routerContext?.disallowedQuotaPolicies,
+            activeSlotsByProvider: routerContext?.activeSlotsByProvider,
+            quotaAvailableByProvider: routerContext?.quotaAvailableByProvider,
+        },
+    };
+}
+function resolveProviderAndModeLegacy(options, role, adapter, exec) {
+    if (options.provider) {
+        return {
+            provider: options.provider,
+            mode: "direct-worker",
+            adapter,
+            selectionReason: "cli-provider-override",
+            overrideSource: "dispatch-flag",
+            providersTried: [options.provider],
+        };
+    }
     const rolePolicy = exec?.providerPolicy?.[role];
     const roleProviders = rolePolicy?.providers ?? [];
     const rotation = exec?.rotation ?? [];
@@ -326,6 +418,15 @@ function determineRuntimeState(mode) {
     return mode === "delegated" ? "delegated" : "packet-created";
 }
 function emitProviderSelected(telemetryFile, dispatchId, runId, childId, decision) {
+    const fallbackAttempts = decision.providersTried.map((provider, index) => {
+        const candidate = decision.routerEvidence?.candidates.find((entry) => entry.provider === provider);
+        return {
+            provider,
+            attempt_index: index + 1,
+            outcome: decision.provider === provider ? "selected" : "rejected",
+            rejection_reasons: candidate?.rejectionReasons ?? [],
+        };
+    });
     appendTelemetry(telemetryFile, {
         event: "provider-selected",
         event_id: (0, node_crypto_1.randomUUID)(),
@@ -336,10 +437,55 @@ function emitProviderSelected(telemetryFile, dispatchId, runId, childId, decisio
         selected_provider: decision.provider ?? null,
         selected_adapter: decision.adapter,
         selection_reason: decision.selectionReason,
+        ...(decision.routerEvidence
+            ? {
+                router_mode: decision.routerEvidence.mode,
+                router_task_type: decision.routerEvidence.selectedWorker.taskType,
+                router_compatibility_mode: decision.routerEvidence.compatibilityMode,
+            }
+            : {}),
+        ...(decision.routerContextSnapshot
+            ? {
+                router_score_inputs: {
+                    required_capabilities: decision.routerContextSnapshot.requiredCapabilities,
+                    min_trust_tier: decision.routerContextSnapshot.minTrustTier,
+                    max_cost_tier: decision.routerContextSnapshot.maxCostTier,
+                    disallowed_quota_policies: decision.routerContextSnapshot.disallowedQuotaPolicies,
+                    active_slots_by_provider: decision.routerContextSnapshot.activeSlotsByProvider,
+                    quota_available_by_provider: decision.routerContextSnapshot.quotaAvailableByProvider,
+                },
+            }
+            : {}),
+        ...(fallbackAttempts.length > 0 ? { fallback_attempts: fallbackAttempts } : {}),
         ...(decision.overrideSource ? { override_source: decision.overrideSource } : {}),
         ...(decision.fallbackFrom ? { fallback_from: decision.fallbackFrom } : {}),
         ...(decision.fallbackReason ? { fallback_reason: decision.fallbackReason } : {}),
         ...(decision.providersTried.length > 0 ? { providers_tried: decision.providersTried } : {}),
+        ...(decision.exhaustedReason ? { router_exhausted_reason: decision.exhaustedReason } : {}),
+        ...(decision.routerEvidence?.candidates?.length
+            ? {
+                router_candidates: decision.routerEvidence.candidates.map((candidate) => ({
+                    provider: candidate.provider,
+                    eligible: candidate.eligible,
+                    rejection_reasons: candidate.rejectionReasons,
+                    score: {
+                        order: candidate.score.orderScore,
+                        trust: candidate.score.trustScore,
+                        cost: candidate.score.costScore,
+                        total: candidate.score.total,
+                    },
+                    inputs: {
+                        order_index: candidate.evidence.orderIndex,
+                        trust_tier: candidate.evidence.trustTier,
+                        cost_tier: candidate.evidence.costTier,
+                        quota_policy: candidate.evidence.quotaPolicy,
+                        active_slots: candidate.evidence.activeSlots,
+                        slot_limit: candidate.evidence.slotLimit,
+                        policy_matched: candidate.evidence.policyMatched,
+                    },
+                })),
+            }
+            : {}),
         timestamp: new Date().toISOString(),
     });
 }
@@ -355,6 +501,10 @@ function emitProviderFallbackAttempted(telemetryFile, dispatchId, runId, childId
         requested_role: "worker",
         fallback_from: decision.fallbackFrom,
         fallback_reason: decision.fallbackReason,
+        ...(decision.provider ? { fallback_to: decision.provider } : {}),
+        ...(decision.providersTried.length > 0
+            ? { fallback_attempt_index: decision.providersTried.length }
+            : {}),
         ...(decision.providersTried.length > 0 ? { providers_tried: decision.providersTried } : {}),
         timestamp: new Date().toISOString(),
     });
@@ -664,7 +814,7 @@ function selectChild(state, requestedChild) {
  * @param resultFile - Optional path for the expected result file; non-absolute paths are resolved against `repoRoot`
  * @returns The constructed WorkerPacket ready for dispatch
  */
-function buildPacket(state, childId, stateFile, telemetryFile, repoRoot, resultFile, config) {
+function buildPacket(state, childId, stateFile, telemetryFile, repoRoot, resultFile, maxConcurrentWorkers, config) {
     const childMeta = state.open_children_meta?.[childId];
     // Hydrate body from cluster snapshot when runtime state lacks it.
     const cachedBody = childMeta?.body;
@@ -697,7 +847,7 @@ function buildPacket(state, childId, stateFile, telemetryFile, repoRoot, resultF
         telemetryFile,
         issueContext,
         allowedScope: resolvedScope.length > 0 ? resolvedScope : undefined,
-        maxConcurrentWorkers: 1,
+        maxConcurrentWorkers,
         promptMode: (0, worker_prompt_js_1.selectPromptMode)(childId, state),
         simplicityMode: resolveSimplicityMode(state, config),
         resultFile: canonicalPath(absoluteResultFile(repoRoot, resultFile)),
@@ -918,7 +1068,7 @@ function runLoopDispatch(options) {
         step_cursor: "dispatch",
         dispatch_boundary: (0, dispatch_boundary_js_1.advanceDispatchEpoch)(state.dispatch_boundary, childId),
     };
-    const packet = buildPacket(preliminaryState, childId, options.stateFile, telemetryFile, options.repoRoot, canonicalResultFile, loadedConfig);
+    const packet = buildPacket(preliminaryState, childId, options.stateFile, telemetryFile, options.repoRoot, canonicalResultFile, loadedConfig?.execution?.routerPolicy?.defaultWorkerPool?.maxActiveWorkers ?? 1, loadedConfig);
     const packetFailure = detectPacketGenerationFailure(packet);
     if (packetFailure) {
         appendTelemetry(telemetryFile, {
@@ -932,22 +1082,38 @@ function runLoopDispatch(options) {
         fail(`${packetFailure.message} (missing_field=${packetFailure.missingField}, child_id=${childId})`);
     }
     const targetRole = roleContextToExecutionRole(packet.role_context.role);
+    const taskType = roleContextToTaskType(packet.role_context);
+    const activeSlotsByProvider = collectActiveProviderSlots(state);
     // ── Resolve provider and dispatch mode ─────────────────────────────────────
     // loadedConfig was loaded earlier (above bootstrap seal check)
     let providerDecision;
     try {
-        providerDecision = resolveProviderAndMode(options, targetRole, loadedConfig);
+        providerDecision = resolveProviderAndMode(options, targetRole, loadedConfig, {
+            taskType,
+            requiredCapabilities: requiredCapabilitiesForTask(taskType),
+            activeSlotsByProvider,
+        });
     }
     catch (err) {
         fail(err instanceof Error ? err.message : String(err));
     }
+    // ── Handle hard-exhaustion: emit telemetry before failing ──────────────────
+    // resolveProviderAndMode returns (not throws) when all providers are rejected so
+    // emitProviderExhausted/emitProviderSelected can record the candidate breakdown.
+    if (!providerDecision.provider && providerDecision.exhaustedReason && providerDecision.routerEvidence) {
+        emitProviderExhausted(telemetryFile, dispatchId, state.run_id, childId, providerDecision);
+        emitProviderSelected(telemetryFile, dispatchId, state.run_id, childId, providerDecision);
+        fail(`provider dispatch forbidden: router rejected all providers (reason=${providerDecision.exhaustedReason})`);
+    }
     const { provider: resolvedProvider } = providerDecision;
     const providerPolicy = loadedConfig?.execution.providerPolicy ?? getProviderPolicy(options.repoRoot);
-    try {
-        assertProviderAllowedForRole(targetRole, resolvedProvider, providerPolicy, telemetryFile, dispatchId, state.run_id, childId);
-    }
-    catch (err) {
-        fail(err instanceof Error ? err.message : String(err));
+    if (!providerDecision.routerEvidence) {
+        try {
+            assertProviderAllowedForRole(targetRole, resolvedProvider, providerPolicy, telemetryFile, dispatchId, state.run_id, childId);
+        }
+        catch (err) {
+            fail(err instanceof Error ? err.message : String(err));
+        }
     }
     // ── Provider probe on first dispatch ──────────────────────────────────────
     // Catches provider configuration failures before packet commit. Only runs on
@@ -962,6 +1128,11 @@ function runLoopDispatch(options) {
                     run_id: state.run_id,
                     child_id: childId,
                     provider: resolvedProvider,
+                    failure_origin: "provider-launch",
+                    failure_category: "provider-unavailable",
+                    pre_dispatch_failure: true,
+                    fallback_eligible: true,
+                    providers_tried: providerDecision.providersTried,
                     error: probeResult.error,
                     timestamp: new Date().toISOString(),
                 });
@@ -1080,7 +1251,7 @@ function runLoopDispatch(options) {
     if (loadedConfig) {
         let adapter;
         try {
-            adapter = (0, index_js_1.loadTrackerAdapter)(loadedConfig);
+            adapter = (0, index_js_2.loadTrackerAdapter)(loadedConfig);
         }
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : String(err);