@lsctech/polaris 0.4.9 → 0.5.0

package/dist/loop/orphan-recovery.js

@@ -64,6 +64,42 @@ function hasTelemetryEvent(telemetryFile, eventName, childId) {
     catch { /* ignore */ }
     return false;
 }
+function latestProviderFailureReason(telemetryFile, childId, dispatchId) {
+    if (!(0, node_fs_1.existsSync)(telemetryFile))
+        return null;
+    try {
+        const lines = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8").trim().split("\n").filter(Boolean);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i];
+            if (!line)
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (event.child_id !== childId)
+                    continue;
+                if (event.dispatch_id && event.dispatch_id !== dispatchId)
+                    continue;
+                const category = typeof event.failure_category === "string" ? event.failure_category : undefined;
+                const reason = typeof event.reason === "string" ? event.reason : undefined;
+                if (category === "quota-exhausted" || reason === "quota-exhausted") {
+                    return "quota-exhausted";
+                }
+                if (category === "provider-unavailable" ||
+                    reason === "provider-unavailable" ||
+                    event.event === "provider-probe-failed") {
+                    return "provider-unavailable";
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
 // ── Emit recovery telemetry events ───────────────────────────────────────────
 function emitRecoveryInitiated(telemetryFile, childId, dispatchId, reason) {
     appendTelemetry(telemetryFile, {
@@ -187,6 +223,26 @@ function checkOrphans(options) {
         if (dr && dr.runtime_state !== "completed" && dr.runtime_state !== "failed") {
             const dispatchedAt = new Date(dr.dispatched_at).getTime();
             const elapsed = now - dispatchedAt;
+            const providerFailure = latestProviderFailureReason(telemetryFile, state.active_child, dr.dispatch_id);
+            // Provider launch failure detected before worker-start evidence.
+            // Safe to requeue because no worker result artifact exists and there is
+            // no heartbeat/acknowledgment evidence that execution started.
+            if (providerFailure &&
+                !safeResultExists(dr.expected_result_path) &&
+                !dr.first_heartbeat_at) {
+                const detection = {
+                    childId: state.active_child,
+                    dispatchId: dr.dispatch_id,
+                    reason: providerFailure,
+                    requiresApproval: false,
+                };
+                detected.push(detection);
+                emitRecoveryInitiated(telemetryFile, state.active_child, dr.dispatch_id, providerFailure);
+                emitChildOrphaned(telemetryFile, state.active_child, dr.dispatch_id, null);
+                const newId = resetForRedispatch(options.stateFile, state, state.active_child);
+                emitChildRequeued(telemetryFile, state.active_child, newId, dr.dispatch_id);
+                return { detected, checked };
+            }
             // Scenario A: packet written, no worker_id after launch_timeout
             if (!dr.worker_id && elapsed > timeouts.launchTimeoutMs) {
                 const detection = {

package/dist/loop/parent.js

@@ -39,8 +39,11 @@ 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 dispatch_js_1 = require("./dispatch.js");
-const index_js_1 = require("../tracker/index.js");
+const index_js_1 = require("./router/index.js");
+const child_selector_js_1 = require("../runtime/scheduling/child-selector.js");
+const index_js_2 = require("../tracker/index.js");
 const lifecycle_transition_js_1 = require("../tracker/lifecycle-transition.js");
+const local_graph_js_1 = require("../tracker/local-graph.js");
 const CLAIM_TTL_MS = 30 * 60 * 1000;
 /**
  * Returns the list of files touched by a git commit, or null when the commit
@@ -130,13 +133,6 @@ function emitBootstrapContextSize(telemetryFile, runId, childId, stateFile, pack
         timestamp: new Date().toISOString(),
     });
 }
-/**
- * Select the next open child that is not Done/blocked.
- * Returns null when all children are completed.
- */
-function selectNextChild(state) {
-    return state.open_children[0] ?? null;
-}
 /**
  * Returns true when the given child is detected as an analyze issue.
  * Detection is intentionally conservative: title prefix or label match only.
@@ -212,7 +208,7 @@ function appendRunStartedLedgerEvent(repoRoot, state) {
         timestamp: new Date().toISOString(),
     });
 }
-function appendChildCompletedLedgerEvent(repoRoot, state, completedChild, lastCommit, validation) {
+function appendChildCompletedLedgerEvent(repoRoot, state, completedChild, lastCommit, validation, completion) {
     const writer = new ledger_js_1.LedgerWriter((0, node_path_1.join)(repoRoot, ledger_js_1.DEFAULT_LEDGER_PATH));
     const base = {
         schema_version: 1,
@@ -237,6 +233,18 @@ function appendChildCompletedLedgerEvent(repoRoot, state, completedChild, lastCo
         validation: typeof validation === "object" && validation !== null
             ? { status: "complete", ...validation }
             : { status: "complete" },
+        ...(completion?.dispatchId ? { dispatch_id: completion.dispatchId } : {}),
+        provider: completion?.provider ?? null,
+        model: completion?.model ?? null,
+        ...(completion?.elapsedSeconds !== undefined ? { elapsed_seconds: completion.elapsedSeconds } : {}),
+        ...(completion?.commitFiles !== undefined ? { commit_files: completion.commitFiles } : {}),
+        ...(completion?.completionStatus ? { completion_status: completion.completionStatus } : {}),
+        ...(completion?.routerSelectionReason
+            ? { router_selection_reason: completion.routerSelectionReason }
+            : {}),
+        ...(completion?.providersTried?.length
+            ? { providers_tried: completion.providersTried }
+            : {}),
     });
 }
 function appendClusterCompletedLedgerEvent(repoRoot, state) {
@@ -275,7 +283,7 @@ function appendClusterCompletedLedgerEvent(repoRoot, state) {
  * @param resultFile - Optional override path where the worker should write its result
  * @returns The compiled WorkerPacket configured for `activeChild`
  */
-function buildPacket(state, activeChild, stateFile, telemetryFile, repoRoot, resultFile) {
+function buildPacket(state, activeChild, stateFile, telemetryFile, repoRoot, resultFile, maxConcurrentWorkers) {
     const branch = state.branch ?? getCurrentBranch(repoRoot);
     const childMeta = state.open_children_meta?.[activeChild];
     // Hydrate body from cluster snapshot when runtime state lacks it.
@@ -312,7 +320,7 @@ function buildPacket(state, activeChild, stateFile, telemetryFile, repoRoot, res
         telemetryFile,
         issueContext,
         allowedScope: resolvedScope.length > 0 ? resolvedScope : undefined,
-        maxConcurrentWorkers: 1,
+        maxConcurrentWorkers,
         promptMode,
         resultFile,
     });
@@ -416,6 +424,8 @@ function buildParentDispatchRecord(args) {
         packet_path: args.packetPath,
         expected_result_path: args.resultPath,
         provider: args.provider,
+        provider_selection_reason: args.providerSelectionReason,
+        providers_tried: args.providersTried,
         dispatched_at: args.dispatchedAt,
         status: "dispatched",
         dispatch_mode: "direct-worker",
@@ -487,6 +497,26 @@ function advanceState(state, completedChild, lastCommit) {
         },
     };
 }
+function withWorkerPoolState(state, maxConcurrentWorkers, slotClaims) {
+    return {
+        ...state,
+        worker_pool_state: {
+            max_concurrent: maxConcurrentWorkers,
+            slot_claims: slotClaims,
+        },
+    };
+}
+function pruneWorkerPoolClaimsForChild(state, childId) {
+    if (!state.worker_pool_state)
+        return state;
+    return {
+        ...state,
+        worker_pool_state: {
+            ...state.worker_pool_state,
+            slot_claims: state.worker_pool_state.slot_claims.filter((claim) => claim.child_id !== childId),
+        },
+    };
+}
 async function syncClusterCompletion(args) {
     const clusterState = await (0, store_js_1.readClusterState)(args.clusterId, args.repoRoot);
     if (!clusterState) {
@@ -651,8 +681,12 @@ async function runParentLoop(options) {
     const notificationFormat = config.orchestration?.notification_format ?? (orchestrationMode === 'auto' ? 'terse' : 'verbose');
     const adapterName = legacyEphemeralMode ? "agent-subtask" : (options.adapter ?? config.execution?.adapter ?? "terminal-cli");
     let providerName;
+    let providerSelectionReason;
+    let providersTried;
     if (adapterName === "agent-subtask") {
         providerName = "agent-subtask";
+        providerSelectionReason = "agent-subtask-adapter";
+        providersTried = ["agent-subtask"];
     }
     else {
         let evidence;
@@ -668,6 +702,8 @@ async function runParentLoop(options) {
             };
         }
         providerName = evidence.provider ?? "default";
+        providerSelectionReason = evidence.selectionReason;
+        providersTried = evidence.providersTried;
     }
     const executionConfig = adapterName === "agent-subtask"
         ? { ...(config.execution ?? { providers: {} }), adapter: "agent-subtask" }
@@ -675,6 +711,7 @@ async function runParentLoop(options) {
     const adapter = (0, registry_js_1.createAdapter)(adapterName, executionConfig);
     const budgetPolicy = (0, budget_js_1.policyFromConfig)(state.context_budget, config.budget);
     const allowAnalyzeChildren = allowAnalyzeChildrenFlag || (config.budget?.allow_analyze_children === true);
+    const maxConcurrentWorkers = config.execution?.routerPolicy?.defaultWorkerPool?.maxActiveWorkers ?? 1;
     const telemetryFile = resolveTelemetryFile(state, repoRoot);
     // Enforce provider policy for explicit --provider flag before entering the loop.
     // resolveProviderAndMode handles policy-filtered rotation; this gate blocks an
@@ -725,18 +762,80 @@ async function runParentLoop(options) {
     if (!dryRun) {
         flushBodiesToClusterSnapshot(state, repoRoot);
     }
+    let localGraph = null;
+    try {
+        localGraph = await local_graph_js_1.LocalGraph.load(state.cluster_id, repoRoot);
+    }
+    catch {
+        localGraph = null;
+    }
     // ── Lifecycle manager: enforce one-active-worker policy ─────────────────
     // forceReleaseAll() clears any orphaned registrations from a previous
     // crashed session. Registrations are session-memory only; they are not
     // persisted to disk, so a fresh loop start always begins clean.
-    const lifecycle = new lifecycle_js_1.WorkerLifecycleManager(1);
+    const lifecycle = new lifecycle_js_1.WorkerLifecycleManager(maxConcurrentWorkers);
     lifecycle.forceReleaseAll();
     // ── Main dispatch loop ───────────────────────────────────────────────────
     // eslint-disable-next-line no-constant-condition
     while (true) {
         // ── Step 02: Select next open child ─────────────────────────────────
-        const nextChild = selectNextChild(state);
+        const existingSlotClaims = state.worker_pool_state?.slot_claims ?? [];
+        if (!dryRun) {
+            const clusterState = await (0, store_js_1.readClusterState)(state.cluster_id, repoRoot);
+            if (clusterState) {
+                const pruned = (0, store_js_1.pruneExpiredClaims)(clusterState);
+                if (pruned.expiredChildIds.length > 0) {
+                    await (0, store_js_1.writeClusterState)(state.cluster_id, pruned.state, repoRoot);
+                }
+            }
+        }
+        const selection = (0, child_selector_js_1.selectChildSlotClaims)({
+            open_children: state.open_children,
+            completed_children: state.completed_children,
+            active_child: state.active_child || null,
+            existing_claims: existingSlotClaims,
+            max_concurrent: maxConcurrentWorkers,
+            claim_ttl_ms: CLAIM_TTL_MS,
+            get_dependencies: (childId) => localGraph?.getDependencies(childId) ?? [],
+            decide_route: ({ activeSlotsByProvider }) => (0, index_js_1.decideWorkerRoute)({
+                role: "worker",
+                taskType: "impl",
+                adapter: adapterName,
+                providerOverride: options.provider,
+                providers: Object.keys(config.execution?.providers ?? {}),
+                rotation: config.execution?.rotation ?? [],
+                rolePolicy: config.execution?.providerPolicy?.worker,
+                roleConfiguredProvider: config.execution?.roles?.worker?.provider,
+                routerPolicy: config.execution?.routerPolicy,
+                constraints: {
+                    requiredCapabilities: ["implementation"],
+                },
+                runtime: {
+                    activeSlotsByProvider,
+                },
+                compatibilityMode: false,
+            }),
+        });
+        const nextSlotClaims = selection.slot_claims;
+        const nextChild = selection.selected_child;
         if (nextChild === null) {
+            if (state.open_children.length > 0) {
+                if (!dryRun) {
+                    appendTelemetry(telemetryFile, {
+                        event: "scheduler-no-eligible-child",
+                        run_id: state.run_id,
+                        open_children: state.open_children,
+                        rejected_children: selection.rejected_children,
+                        slot_claims: nextSlotClaims,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+                return {
+                    haltReason: "blocked",
+                    childrenDispatched,
+                    message: "No schedulable child matched dependency and router slot constraints.",
+                };
+            }
             const autoFinalizeRequested = orchestrationMode === "auto" && config.orchestration?.auto_finalize === true;
             // All children completed — write final state and halt
             if (!dryRun) {
@@ -979,7 +1078,7 @@ async function runParentLoop(options) {
         (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(resultFile), { recursive: true });
         const statePreDispatch = state;
         let stateBeforeDispatch = state;
-        const packet = buildPacket(state, nextChild, stateFile, telemetryFile, repoRoot, resultFile);
+        const packet = buildPacket(state, nextChild, stateFile, telemetryFile, repoRoot, resultFile, maxConcurrentWorkers);
         if (!dryRun) {
             try {
                 writePacketArtifact(packetPath, packet);
@@ -1009,11 +1108,13 @@ async function runParentLoop(options) {
                 packetPath,
                 resultPath: resultFile,
                 provider: providerName,
+                providerSelectionReason,
+                providersTried,
                 workerId,
                 dispatchedAt,
             });
             const stateWithDispatch = {
-                ...withChildDispatchMetadata(state, nextChild, resultFile, dispatchRecord),
+                ...withWorkerPoolState(withChildDispatchMetadata(state, nextChild, resultFile, dispatchRecord), maxConcurrentWorkers, nextSlotClaims),
                 active_child: nextChild,
                 step_cursor: "dispatch",
                 dispatch_boundary: (0, dispatch_boundary_js_1.advanceDispatchEpoch)(state.dispatch_boundary, nextChild),
@@ -1066,6 +1167,7 @@ async function runParentLoop(options) {
         if (!dryRun) {
             const totalChildren = state.open_children.length + state.completed_children.length;
             const childIndex = state.completed_children.length + 1;
+            const selectedSlotClaim = nextSlotClaims.find((claim) => claim.child_id === nextChild);
             logStatus(notificationFormat, `RUNNING ${nextChild} (${childIndex}/${totalChildren})`);
             appendTelemetry(telemetryFile, {
                 event: "child-dispatched",
@@ -1080,6 +1182,8 @@ async function runParentLoop(options) {
                 packet_path: packetPath,
                 expected_result_path: resultFile,
                 dry_run: dryRun,
+                selected_slot_claim: selectedSlotClaim ?? null,
+                slot_claims: nextSlotClaims,
                 timestamp: new Date().toISOString(),
             });
             emitBootstrapContextSize(telemetryFile, state.run_id, nextChild, stateFile, packet);
@@ -1229,7 +1333,7 @@ async function runParentLoop(options) {
                 // Errors are logged to telemetry but do not fail the halt.
                 let adapter;
                 try {
-                    adapter = (0, index_js_1.loadTrackerAdapter)(config);
+                    adapter = (0, index_js_2.loadTrackerAdapter)(config);
                 }
                 catch (err) {
                     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -1423,6 +1527,14 @@ async function runParentLoop(options) {
             finalWorkerSummary?.['commit_hash'];
         const validationSummary = finalWorkerSummary?.['validation'] ??
             finalWorkerSummary?.['validation_summary'];
+        const dispatchRecord = state.open_children_meta?.[nextChild]?.dispatch_record;
+        const providerUsed = finalWorkerSummary?.['provider'] ??
+            finalWorkerSummary?.['provider_used'] ??
+            dispatchRecord?.provider ??
+            null;
+        const modelUsed = finalWorkerSummary?.['model'] ??
+            finalWorkerSummary?.['model_used'] ??
+            null;
         if (!dryRun && workerStatus === 'done' && (!lastCommit || lastCommit.trim().length === 0)) {
             const errMsg = `Worker reported done for ${nextChild} without commit evidence`;
             appendTelemetry(telemetryFile, {
@@ -1561,14 +1673,14 @@ async function runParentLoop(options) {
             }
             // Advance state, including continue_epoch to match the consumed dispatch
             const advanced = advanceState(state, nextChild, lastCommit);
-            state = {
+            state = pruneWorkerPoolClaimsForChild({
                 ...advanced,
                 dispatch_boundary: (0, dispatch_boundary_js_1.advanceContinueEpoch)(state.dispatch_boundary),
                 completed_children_results: {
                     ...advanced.completed_children_results,
                     [nextChild]: workerResult,
                 },
-            };
+            }, nextChild);
             childrenDispatched += 1;
             // Worker did not write its own completion — orchestrator fills the gap.
             if (!dryRun) {
@@ -1578,14 +1690,14 @@ async function runParentLoop(options) {
         else {
             // Worker wrote its own completion — advance continue_epoch to stay in sync.
             // The worker does not manage dispatch_boundary, so the parent must do it.
-            state = {
+            state = pruneWorkerPoolClaimsForChild({
                 ...state,
                 dispatch_boundary: (0, dispatch_boundary_js_1.advanceContinueEpoch)(state.dispatch_boundary),
                 completed_children_results: {
                     ...state.completed_children_results,
                     [nextChild]: workerResult,
                 },
-            };
+            }, nextChild);
             childrenDispatched += 1;
             if (!dryRun) {
                 (0, checkpoint_js_1.writeStateAtomic)(stateFile, state);
@@ -1641,15 +1753,30 @@ async function runParentLoop(options) {
                 child_id: nextChild,
                 children_completed: state.context_budget.children_completed,
                 validation_summary: validationSummary,
+                completion_status: workerStatus,
                 commit_hash: lastCommit,
                 commit_files: commitFiles,
+                dispatch_id: dispatchRecord?.dispatch_id,
+                provider: providerUsed,
+                model: modelUsed,
+                router_selection_reason: dispatchRecord?.provider_selection_reason,
+                providers_tried: dispatchRecord?.providers_tried,
                 timestamp: new Date().toISOString(),
             };
             if (elapsedSeconds !== undefined) {
                 telemetryEvent.elapsed_seconds = elapsedSeconds;
             }
             appendTelemetry(telemetryFile, telemetryEvent);
-            appendChildCompletedLedgerEvent(repoRoot, state, nextChild, lastCommit ?? null, validationSummary);
+            appendChildCompletedLedgerEvent(repoRoot, state, nextChild, lastCommit ?? null, validationSummary, {
+                dispatchId: dispatchRecord?.dispatch_id,
+                provider: providerUsed,
+                model: modelUsed,
+                elapsedSeconds,
+                commitFiles,
+                completionStatus: workerStatus,
+                routerSelectionReason: dispatchRecord?.provider_selection_reason,
+                providersTried: dispatchRecord?.providers_tried,
+            });
         }
         if (orchestrationMode === 'supervised') {
             return {

package/dist/loop/router/engine.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideWorkerRoute = decideWorkerRoute;
+const TRUST_RANK = {
+    sandbox: 0,
+    standard: 1,
+    trusted: 2,
+};
+const COST_RANK = {
+    low: 0,
+    medium: 1,
+    high: 2,
+};
+function defaultCapabilitiesForTask(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 orderedProviders(input) {
+    if (input.providerOverride) {
+        return [input.providerOverride];
+    }
+    const roleProviders = input.rolePolicy?.providers ?? [];
+    const rotation = input.rotation ?? [];
+    if (input.compatibilityMode !== false) {
+        if (roleProviders.length > 0) {
+            const filteredRotation = rotation.filter((provider) => roleProviders.includes(provider));
+            if (filteredRotation.length > 0) {
+                return filteredRotation;
+            }
+            const configuredProviders = new Set(input.providers);
+            return roleProviders.filter((provider) => configuredProviders.has(provider));
+        }
+        if (input.roleConfiguredProvider) {
+            return [input.roleConfiguredProvider];
+        }
+        if (rotation.length > 0) {
+            return rotation;
+        }
+        return input.providers;
+    }
+    const preferred = rotation.length > 0 ? rotation : input.providers;
+    if (roleProviders.length === 0) {
+        return preferred;
+    }
+    const configuredAndAllowed = new Set(roleProviders.filter((provider) => input.providers.includes(provider)));
+    const ordered = preferred.filter((provider) => configuredAndAllowed.has(provider));
+    if (ordered.length > 0) {
+        return ordered;
+    }
+    return roleProviders.filter((provider) => input.providers.includes(provider));
+}
+function compatibilitySelectionReason(input, selectedProvider) {
+    if (input.providerOverride)
+        return "cli-provider-override";
+    if (!selectedProvider)
+        return "delegated-no-provider";
+    const roleProviders = input.rolePolicy?.providers ?? [];
+    if (roleProviders.length > 0) {
+        const rotation = input.rotation ?? [];
+        if (rotation.filter((provider) => roleProviders.includes(provider))[0] === selectedProvider) {
+            return "policy-filtered-rotation";
+        }
+        return "role-policy";
+    }
+    if (input.roleConfiguredProvider === selectedProvider)
+        return "role-config";
+    if ((input.rotation ?? [])[0] === selectedProvider)
+        return "config-rotation";
+    return "config-first-provider";
+}
+function compatibilityExhaustedReason(input) {
+    const roleProviders = input.rolePolicy?.providers ?? [];
+    if (roleProviders.length > 0)
+        return "role-policy-no-configured-provider";
+    return "no-configured-provider";
+}
+function topRejectionReason(candidates) {
+    const orderedReasons = [
+        "role-disabled",
+        "not-in-policy",
+        "quota-exhausted",
+        "trust-too-low",
+        "capability-mismatch",
+        "cost-policy",
+        "no-slot",
+    ];
+    for (const reason of orderedReasons) {
+        if (candidates.some((candidate) => candidate.rejectionReasons.includes(reason))) {
+            return reason;
+        }
+    }
+    return undefined;
+}
+function decideWorkerRoute(input) {
+    const compatibilityMode = input.compatibilityMode !== false;
+    const providerRegistry = input.routerPolicy?.providerRegistry ?? {};
+    const roleProviders = input.rolePolicy?.providers ?? [];
+    const requiredCapabilities = input.constraints?.requiredCapabilities ?? defaultCapabilitiesForTask(input.taskType);
+    const ordered = orderedProviders(input);
+    const activeSlotsByProvider = input.runtime?.activeSlotsByProvider ?? {};
+    const quotaAvailableByProvider = input.runtime?.quotaAvailableByProvider ?? {};
+    const globalSlotLimit = input.routerPolicy?.defaultWorkerPool?.maxActiveSlots;
+    const candidates = [];
+    if (roleProviders.length === 0 && input.rolePolicy) {
+        return {
+            selectedProvider: undefined,
+            selectedWorker: { role: input.role, taskType: input.taskType },
+            mode: "delegated",
+            selectionReason: compatibilityMode ? "delegated-no-provider" : "router-role-disabled",
+            exhaustedReason: "role-disabled",
+            compatibilityMode,
+            providersTried: [],
+            candidates: [],
+        };
+    }
+    for (const [orderIndex, provider] of ordered.entries()) {
+        const policy = providerRegistry[provider];
+        const rejectionReasons = [];
+        const eligibleRoleSet = new Set(policy?.eligibleRoles ?? []);
+        const policyMatched = !policy || eligibleRoleSet.size === 0 || eligibleRoleSet.has(input.role);
+        if (!policyMatched) {
+            rejectionReasons.push("role-disabled");
+        }
+        if (roleProviders.length > 0 && !roleProviders.includes(provider)) {
+            rejectionReasons.push("not-in-policy");
+        }
+        const capabilitySet = new Set(policy?.capabilities ?? []);
+        const allowedTaskSet = new Set(policy?.taskTypes ?? []);
+        if ((capabilitySet.size > 0 && requiredCapabilities.some((capability) => !capabilitySet.has(capability))) ||
+            (allowedTaskSet.size > 0 && !allowedTaskSet.has(input.taskType))) {
+            rejectionReasons.push("capability-mismatch");
+        }
+        const providerTrust = policy?.trustTier;
+        const minTrust = input.constraints?.minTrustTier;
+        if (providerTrust && minTrust && TRUST_RANK[providerTrust] < TRUST_RANK[minTrust]) {
+            rejectionReasons.push("trust-too-low");
+        }
+        const providerCost = policy?.costTier;
+        const maxCost = input.constraints?.maxCostTier;
+        if (providerCost && maxCost && COST_RANK[providerCost] > COST_RANK[maxCost]) {
+            rejectionReasons.push("cost-policy");
+        }
+        const disallowedQuota = new Set(input.constraints?.disallowedQuotaPolicies ?? []);
+        if (policy?.quotaPolicy && disallowedQuota.has(policy.quotaPolicy)) {
+            rejectionReasons.push("cost-policy");
+        }
+        if (policy?.quotaPolicy && quotaAvailableByProvider[provider] === false) {
+            rejectionReasons.push("quota-exhausted");
+        }
+        const activeSlots = activeSlotsByProvider[provider] ?? 0;
+        const providerSlotLimit = policy?.maxActiveSlots;
+        // Provider-specific maxActiveSlots overrides the global default when present.
+        const effectiveSlotLimit = providerSlotLimit ?? globalSlotLimit;
+        if (effectiveSlotLimit !== undefined && activeSlots >= effectiveSlotLimit) {
+            rejectionReasons.push("no-slot");
+        }
+        const score = {
+            orderScore: Math.max(0, 100 - orderIndex),
+            trustScore: providerTrust ? TRUST_RANK[providerTrust] * 1_000 : 0,
+            costScore: providerCost ? (3 - COST_RANK[providerCost]) * 10 : 0,
+            total: 0,
+        };
+        score.total = score.orderScore + score.trustScore + score.costScore;
+        candidates.push({
+            provider,
+            eligible: rejectionReasons.length === 0,
+            score,
+            rejectionReasons,
+            evidence: {
+                orderIndex,
+                trustTier: providerTrust,
+                costTier: providerCost,
+                quotaPolicy: policy?.quotaPolicy,
+                activeSlots,
+                slotLimit: providerSlotLimit ?? globalSlotLimit,
+                policyMatched,
+            },
+        });
+    }
+    const eligibleCandidates = candidates.filter((candidate) => candidate.eligible);
+    const selected = eligibleCandidates
+        .slice()
+        .sort((a, b) => {
+        if (a.score.total !== b.score.total)
+            return b.score.total - a.score.total;
+        if (a.evidence.orderIndex !== b.evidence.orderIndex)
+            return a.evidence.orderIndex - b.evidence.orderIndex;
+        return a.provider.localeCompare(b.provider);
+    })[0];
+    const selectedProvider = selected?.provider;
+    if (!selectedProvider) {
+        const rejection = topRejectionReason(candidates);
+        const exhaustedReason = rejection ?? (compatibilityMode ? compatibilityExhaustedReason(input) : "no-eligible-provider");
+        const selectionReason = compatibilityMode ? "delegated-no-provider" : "router-no-eligible-provider";
+        return {
+            selectedProvider: undefined,
+            selectedWorker: { role: input.role, taskType: input.taskType },
+            mode: "delegated",
+            selectionReason,
+            exhaustedReason,
+            compatibilityMode,
+            providersTried: ordered,
+            candidates,
+        };
+    }
+    return {
+        selectedProvider,
+        selectedWorker: { role: input.role, taskType: input.taskType },
+        mode: "direct-worker",
+        selectionReason: compatibilityMode ? compatibilitySelectionReason(input, selectedProvider) : "policy-router",
+        compatibilityMode,
+        providersTried: ordered,
+        candidates,
+    };
+}

package/dist/loop/router/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideWorkerRoute = void 0;
+var engine_js_1 = require("./engine.js");
+Object.defineProperty(exports, "decideWorkerRoute", { enumerable: true, get: function () { return engine_js_1.decideWorkerRoute; } });

package/dist/loop/router/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });