@lsctech/polaris 0.5.10 → 0.5.12

package/dist/loop/dispatch.js

@@ -139,6 +139,18 @@ function resolveProviderAndMode(options, role, config, routerContext) {
         },
         compatibilityMode: false,
     });
+    const workerPolicy = exec?.providerPolicy?.[role];
+    const noFallback = workerPolicy?.noFallback === true;
+    const fallbackEligible = !noFallback && decision.providersTried.length > 1;
+    const routingSummary = {
+        selected_provider: decision.selectedProvider ?? null,
+        selected_adapter: adapter,
+        selection_reason: decision.selectionReason,
+        effective_policy_order: decision.providersTried,
+        compatibility_mode: false,
+        registry_present: true,
+        fallback_eligible: fallbackEligible,
+    };
     return {
         provider: decision.selectedProvider,
         mode: decision.mode,
@@ -157,91 +169,108 @@ function resolveProviderAndMode(options, role, config, routerContext) {
             activeSlotsByProvider: routerContext?.activeSlotsByProvider,
             quotaAvailableByProvider: routerContext?.quotaAvailableByProvider,
         },
+        routingSummary,
     };
 }
 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 noFallback = rolePolicy?.noFallback === true;
     const rotation = exec?.rotation ?? [];
-    if (roleProviders.length > 0) {
+    const configuredProviders = new Set(Object.keys(exec?.providers ?? {}));
+    let provider;
+    let selectionReason;
+    let overrideSource;
+    let fallbackFrom;
+    let fallbackReason;
+    let exhaustedReason;
+    let effectivePolicyOrder;
+    if (options.provider) {
+        provider = options.provider;
+        selectionReason = "cli-provider-override";
+        overrideSource = "dispatch-flag";
+        effectivePolicyOrder = [options.provider];
+    }
+    else if (roleProviders.length > 0) {
         // When a role policy is configured, filter the rotation to only include
         // providers that are allowed by the policy.  This ensures that a provider
         // present in rotation but absent from the policy is never selected.
         const allowedByPolicy = new Set(roleProviders);
-        const configuredProviders = new Set(Object.keys(exec?.providers ?? {}));
         const filteredRotation = rotation.filter((p) => allowedByPolicy.has(p));
+        const availablePolicyProviders = roleProviders.filter((p) => configuredProviders.has(p));
         if (filteredRotation.length > 0 && filteredRotation[0]) {
-            return {
-                provider: filteredRotation[0],
-                mode: "direct-worker",
-                adapter,
-                selectionReason: "policy-filtered-rotation",
-                providersTried: [filteredRotation[0]],
-            };
+            provider = filteredRotation[0];
+            selectionReason = "policy-filtered-rotation";
+            effectivePolicyOrder = filteredRotation.slice();
+            // Surface remaining configured policy providers as fallback alternatives
+            for (const p of availablePolicyProviders) {
+                if (!effectivePolicyOrder.includes(p)) {
+                    effectivePolicyOrder.push(p);
+                }
+            }
         }
-        // No rotation entry is in the policy — fall back to first policy provider
-        // that is actually configured.  If none is configured, fail before mutation.
-        const availablePolicyProviders = roleProviders.filter((p) => configuredProviders.has(p));
-        if (availablePolicyProviders.length > 0 && availablePolicyProviders[0]) {
-            return {
-                provider: availablePolicyProviders[0],
-                mode: "direct-worker",
-                adapter,
-                selectionReason: "role-policy",
-                providersTried: [availablePolicyProviders[0]],
-            };
+        else if (availablePolicyProviders.length > 0 && availablePolicyProviders[0]) {
+            provider = availablePolicyProviders[0];
+            selectionReason = "role-policy";
+            effectivePolicyOrder = availablePolicyProviders.slice();
+        }
+        else {
+            // No configured provider satisfies the policy — fail clearly before dispatch.
+            throw new Error(`provider dispatch forbidden: no configured provider satisfies the "${role}" role policy (policy=${roleProviders.join(",")})`);
         }
-        // No configured provider satisfies the policy — fail clearly before dispatch.
-        throw new Error(`provider dispatch forbidden: no configured provider satisfies the "${role}" role policy (policy=${roleProviders.join(",")})`);
     }
-    const roleProvider = exec?.roles?.[role]?.provider;
-    if (roleProvider) {
-        return {
-            provider: roleProvider,
-            mode: "direct-worker",
-            adapter,
-            selectionReason: "role-config",
-            providersTried: [roleProvider],
-        };
+    else if (exec?.roles?.[role]?.provider) {
+        provider = exec.roles[role].provider;
+        selectionReason = "role-config";
+        effectivePolicyOrder = [provider];
+        // If a role policy exists for this role, include its other providers as alternatives
+        for (const p of roleProviders) {
+            if (p !== provider && !effectivePolicyOrder.includes(p)) {
+                effectivePolicyOrder.push(p);
+            }
+        }
     }
-    if (rotation.length > 0 && rotation[0]) {
-        return {
-            provider: rotation[0],
-            mode: "direct-worker",
-            adapter,
-            selectionReason: "config-rotation",
-            providersTried: [rotation[0]],
-        };
+    else if (rotation.length > 0 && rotation[0]) {
+        provider = rotation[0];
+        selectionReason = "config-rotation";
+        effectivePolicyOrder = rotation.slice();
     }
-    const providers = Object.keys(exec?.providers ?? {});
-    if (providers.length > 0 && providers[0]) {
-        return {
-            provider: providers[0],
-            mode: "direct-worker",
-            adapter,
-            selectionReason: "config-first-provider",
-            fallbackFrom: "rotation",
-            fallbackReason: "rotation-empty",
-            providersTried: [providers[0]],
-        };
+    else {
+        const providers = Object.keys(exec?.providers ?? {});
+        if (providers.length > 0 && providers[0]) {
+            provider = providers[0];
+            selectionReason = "config-first-provider";
+            fallbackFrom = "rotation";
+            fallbackReason = "rotation-empty";
+            effectivePolicyOrder = providers.slice();
+        }
+        else {
+            selectionReason = "delegated-no-provider";
+            exhaustedReason = "no-configured-provider";
+            effectivePolicyOrder = [];
+        }
     }
+    const fallbackEligible = !noFallback && effectivePolicyOrder.length > 1;
+    const routingSummary = {
+        selected_provider: provider ?? null,
+        selected_adapter: adapter,
+        selection_reason: selectionReason,
+        effective_policy_order: effectivePolicyOrder,
+        compatibility_mode: true,
+        registry_present: false,
+        fallback_eligible: fallbackEligible,
+    };
     return {
-        provider: undefined,
-        mode: "delegated",
+        provider,
+        mode: provider ? "direct-worker" : "delegated",
         adapter,
-        selectionReason: "delegated-no-provider",
-        providersTried: [],
-        exhaustedReason: "no-configured-provider",
+        selectionReason,
+        overrideSource,
+        fallbackFrom,
+        fallbackReason,
+        providersTried: provider ? [provider] : [],
+        exhaustedReason,
+        routingSummary,
     };
 }
 function fail(message) {
@@ -464,6 +493,7 @@ function emitProviderSelected(telemetryFile, dispatchId, runId, childId, decisio
         ...(decision.fallbackReason ? { fallback_reason: decision.fallbackReason } : {}),
         ...(decision.providersTried.length > 0 ? { providers_tried: decision.providersTried } : {}),
         ...(decision.exhaustedReason ? { router_exhausted_reason: decision.exhaustedReason } : {}),
+        ...(decision.routingSummary ? { routing_summary: decision.routingSummary } : {}),
         ...(decision.routerEvidence?.candidates?.length
             ? {
                 router_candidates: decision.routerEvidence.candidates.map((candidate) => ({
@@ -484,6 +514,7 @@ function emitProviderSelected(telemetryFile, dispatchId, runId, childId, decisio
                         active_slots: candidate.evidence.activeSlots,
                         slot_limit: candidate.evidence.slotLimit,
                         policy_matched: candidate.evidence.policyMatched,
+                        fallback_eligible: candidate.evidence.fallbackEligible,
                     },
                 })),
             }
@@ -574,7 +605,7 @@ function assertProviderAllowedForRole(role, provider, policy, telemetryFile, dis
 /**
  * Create a dispatch record with all required evidence.
  */
-function createDispatchRecord(runId, clusterId, childId, packetPath, resultPath, roleContext, provider, providerSelectionReason, providerOverrideSource, providersTried) {
+function createDispatchRecord(runId, clusterId, childId, packetPath, resultPath, roleContext, provider, providerSelectionReason, providerOverrideSource, providersTried, routingSummary) {
     const dispatchMode = determineDispatchMode(provider);
     const runtimeState = determineRuntimeState(dispatchMode);
     return {
@@ -588,6 +619,7 @@ function createDispatchRecord(runId, clusterId, childId, packetPath, resultPath,
         provider_selection_reason: providerSelectionReason,
         provider_override_source: providerOverrideSource,
         providers_tried: providersTried && providersTried.length > 0 ? providersTried : undefined,
+        routing_summary: routingSummary,
         dispatched_at: new Date().toISOString(),
         status: "dispatched",
         dispatch_mode: dispatchMode,
@@ -755,6 +787,7 @@ function ledgerLastCommit(state) {
     return state.last_commit && state.last_commit.length > 0 ? state.last_commit : null;
 }
 function appendDispatchLedgerEvent(repoRoot, state, childId) {
+    const routingSummary = state.open_children_meta?.[childId]?.dispatch_record?.routing_summary;
     new ledger_js_1.LedgerWriter((0, node_path_1.join)(repoRoot, ledger_js_1.DEFAULT_LEDGER_PATH)).append({
         schema_version: 1,
         event_id: (0, node_crypto_1.randomUUID)(),
@@ -772,6 +805,7 @@ function appendDispatchLedgerEvent(repoRoot, state, childId) {
         pr_url: null,
         timestamp: new Date().toISOString(),
         dispatch_epoch: state.dispatch_boundary?.dispatch_epoch ?? 0,
+        ...(routingSummary ? { routing_summary: routingSummary } : {}),
     });
 }
 function selectChild(state, requestedChild) {
@@ -1189,7 +1223,7 @@ function runLoopDispatch(options) {
         fail(`Failed to write packet artifact to ${packetPath}: ${errorMsg}`);
     }
     // Create dispatch record with all evidence
-    const dispatchRecord = createDispatchRecord(state.run_id, state.cluster_id, childId, relativePacketPath, relativeEffectiveResultPath, packet.role_context, resolvedProvider, providerDecision.selectionReason, providerDecision.overrideSource, providerDecision.providersTried);
+    const dispatchRecord = createDispatchRecord(state.run_id, state.cluster_id, childId, relativePacketPath, relativeEffectiveResultPath, packet.role_context, resolvedProvider, providerDecision.selectionReason, providerDecision.overrideSource, providerDecision.providersTried, providerDecision.routingSummary);
     emitProviderFallbackAttempted(telemetryFile, dispatchRecord.dispatch_id, state.run_id, childId, providerDecision);
     emitProviderExhausted(telemetryFile, dispatchRecord.dispatch_id, state.run_id, childId, providerDecision);
     emitProviderSelected(telemetryFile, dispatchRecord.dispatch_id, state.run_id, childId, providerDecision);
@@ -1245,6 +1279,7 @@ function runLoopDispatch(options) {
         dispatch_mode: dispatchRecord.dispatch_mode,
         runtime_state: dispatchRecord.runtime_state,
         provider: dispatchRecord.provider ?? null,
+        routing_summary: dispatchRecord.routing_summary ?? null,
         timestamp: new Date().toISOString(),
     });
     // ── Apply lifecycle transition for child-dispatch event ────────────────────

package/dist/loop/parent.js

@@ -254,6 +254,7 @@ function appendChildCompletedLedgerEvent(repoRoot, state, completedChild, lastCo
         ...(completion?.providersTried?.length
             ? { providers_tried: completion.providersTried }
             : {}),
+        ...(completion?.routingSummary ? { routing_summary: completion.routingSummary } : {}),
     });
 }
 function appendClusterCompletedLedgerEvent(repoRoot, state) {
@@ -435,6 +436,7 @@ function buildParentDispatchRecord(args) {
         provider: args.provider,
         provider_selection_reason: args.providerSelectionReason,
         providers_tried: args.providersTried,
+        routing_summary: args.routingSummary,
         dispatched_at: args.dispatchedAt,
         status: "dispatched",
         dispatch_mode: "direct-worker",
@@ -557,15 +559,16 @@ async function syncClusterCompletion(args) {
                 output: String(args.validationSummary),
             },
         };
+    const relativeResultFile = args.resultFile ? (0, node_path_1.relative)(args.repoRoot, args.resultFile) : args.resultFile;
     await (0, store_js_1.writeClusterState)(args.clusterId, {
         ...clusterState,
         state_generation: clusterState.state_generation + 1,
         child_states: childStates,
         claim_metadata: Object.fromEntries(Object.entries(clusterState.claim_metadata).filter(([childId]) => childId !== args.childId)),
-        result_pointers: args.resultFile
+        result_pointers: relativeResultFile
             ? {
                 ...clusterState.result_pointers,
-                [args.childId]: args.resultFile,
+                [args.childId]: relativeResultFile,
             }
             : clusterState.result_pointers,
         validation_results: nextValidationResults,
@@ -594,6 +597,7 @@ async function syncClusterDispatch(args) {
             }
             : child)
         : [...clusterState.child_states, { id: args.childId, status: "dispatched" }];
+    const relativePacketPath = (0, node_path_1.relative)(args.repoRoot, args.packetPath);
     await (0, store_js_1.writeClusterState)(args.clusterId, {
         ...clusterState,
         state_generation: clusterState.state_generation + 1,
@@ -608,7 +612,7 @@ async function syncClusterDispatch(args) {
         },
         packet_pointers: {
             ...clusterState.packet_pointers,
-            [args.childId]: args.packetPath,
+            [args.childId]: relativePacketPath,
         },
     }, args.repoRoot);
     return true;
@@ -692,10 +696,20 @@ async function runParentLoop(options) {
     let providerName;
     let providerSelectionReason;
     let providersTried;
+    let routingSummary;
     if (adapterName === "agent-subtask") {
         providerName = "agent-subtask";
         providerSelectionReason = "agent-subtask-adapter";
         providersTried = ["agent-subtask"];
+        routingSummary = {
+            selected_provider: "agent-subtask",
+            selected_adapter: "agent-subtask",
+            selection_reason: "agent-subtask-adapter",
+            effective_policy_order: ["agent-subtask"],
+            compatibility_mode: false,
+            registry_present: false,
+            fallback_eligible: false,
+        };
     }
     else {
         let evidence;
@@ -713,6 +727,7 @@ async function runParentLoop(options) {
         providerName = evidence.provider ?? "default";
         providerSelectionReason = evidence.selectionReason;
         providersTried = evidence.providersTried;
+        routingSummary = evidence.routingSummary;
     }
     const executionConfig = adapterName === "agent-subtask"
         ? { ...(config.execution ?? { providers: {} }), adapter: "agent-subtask" }
@@ -1489,6 +1504,7 @@ async function runParentLoop(options) {
                 provider: providerName,
                 providerSelectionReason,
                 providersTried,
+                routingSummary,
                 workerId,
                 dispatchedAt,
             });
@@ -1563,6 +1579,7 @@ async function runParentLoop(options) {
                 dry_run: dryRun,
                 selected_slot_claim: selectedSlotClaim ?? null,
                 slot_claims: nextSlotClaims,
+                routing_summary: routingSummary ?? null,
                 timestamp: new Date().toISOString(),
             });
             emitBootstrapContextSize(telemetryFile, state.run_id, nextChild, stateFile, packet);
@@ -2213,6 +2230,7 @@ async function runParentLoop(options) {
                 model: modelUsed,
                 router_selection_reason: dispatchRecord?.provider_selection_reason,
                 providers_tried: dispatchRecord?.providers_tried,
+                routing_summary: dispatchRecord?.routing_summary ?? null,
                 timestamp: new Date().toISOString(),
             };
             if (elapsedSeconds !== undefined) {
@@ -2228,6 +2246,7 @@ async function runParentLoop(options) {
                 completionStatus: workerStatus,
                 routerSelectionReason: dispatchRecord?.provider_selection_reason,
                 providersTried: dispatchRecord?.providers_tried,
+                routingSummary: dispatchRecord?.routing_summary,
             });
         }
         if (orchestrationMode === 'supervised') {

package/dist/loop/router/engine.js

@@ -188,6 +188,7 @@ function decideWorkerRoute(input) {
                 activeSlots,
                 slotLimit: providerSlotLimit ?? globalSlotLimit,
                 policyMatched,
+                fallbackEligible: policy?.fallbackEligible,
             },
         });
     }

package/dist/loop/run-preflight.js

@@ -220,7 +220,10 @@ async function ensureClusterRunState(options) {
             }
         }
     }
-    const { openChildren, openChildrenMeta } = buildBootstrapPlan(clusterId, await loadOrSyncGraph(clusterId, repoRoot), repoRoot);
+    const graph = await loadOrSyncGraph(clusterId, repoRoot);
+    const { openChildren, openChildrenMeta } = buildBootstrapPlan(clusterId, graph, repoRoot);
+    // Persist canonical child ordering and any body-derived ordering dependencies.
+    await graph.save(clusterId, repoRoot);
     await bootstrapHandler({
         clusterId,
         openChildren,

package/dist/loop/worker-packet.js

@@ -10,6 +10,39 @@
  * WorkerPacket extends BootstrapPacket so all existing adapters that
  * accept BootstrapPacket transparently accept WorkerPacket.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REPAIR_RETURN_CONTRACT = exports.STARTUP_RETURN_CONTRACT = exports.PREFLIGHT_RETURN_CONTRACT = exports.WORKER_SYMPTOM_CATEGORIES = exports.WORKER_PROHIBITED_WRITE_PATHS = exports.FINALIZE_RETURN_CONTRACT = exports.IMPL_RETURN_CONTRACT = void 0;
 exports.roleContextForWorkerRole = roleContextForWorkerRole;
@@ -20,6 +53,7 @@ exports.compileImplPacket = compileImplPacket;
 exports.compileFinalizePacket = compileFinalizePacket;
 exports.compilePreflightPacket = compilePreflightPacket;
 exports.compileRepairWorkerPacket = compileRepairWorkerPacket;
+const path = __importStar(require("node:path"));
 const worker_prompt_js_1 = require("./worker-prompt.js");
 const body_parser_js_1 = require("./body-parser.js");
 const WORKER_ROLE_CONTEXT = {
@@ -172,6 +206,49 @@ function defaultLifecycle(maxConcurrent, cleanupOnExit) {
         cleanup_on_exit: cleanupOnExit,
     };
 }
+/** Derives the adjacent test file path(s) for a single source TypeScript file. */
+function deriveTestPaths(sourcePath) {
+    if (!sourcePath.endsWith('.ts') || sourcePath.endsWith('.test.ts') || sourcePath.endsWith('.d.ts')) {
+        return [];
+    }
+    if (sourcePath.includes('*') || sourcePath.includes('?')) {
+        return [];
+    }
+    const candidates = [sourcePath.replace(/\.ts$/, '.test.ts')];
+    if (sourcePath.endsWith('/index.ts')) {
+        const dir = sourcePath.slice(0, -'/index.ts'.length);
+        const dirName = path.basename(dir);
+        if (dirName) {
+            candidates.push(`${dir}/${dirName}.test.ts`);
+        }
+    }
+    return candidates;
+}
+/**
+ * Expands an allowed scope list with adjacent test paths when the validation
+ * commands include a vitest run. This lets workers touch test files for source
+ * files they are modifying, matching the `*.test.ts` validation commands.
+ */
+function expandScopeWithTestPaths(scope, validationCommands) {
+    const hasVitest = validationCommands.some((cmd) => cmd.includes('vitest'));
+    if (!hasVitest || scope.length === 0)
+        return scope;
+    const testPaths = new Set();
+    for (const item of scope) {
+        for (const testPath of deriveTestPaths(item)) {
+            testPaths.add(testPath);
+        }
+    }
+    if (testPaths.size === 0)
+        return scope;
+    const expanded = [...scope];
+    for (const testPath of testPaths) {
+        if (!expanded.includes(testPath)) {
+            expanded.push(testPath);
+        }
+    }
+    return expanded;
+}
 /**
  * Build a compiled startup worker packet.
  * Startup workers prepare tracker/graph/config/run-state evidence; the parent
@@ -257,6 +334,8 @@ function compileImplPacket(input) {
     const resolvedRequirements = input.issueContext?.key_requirements.length
         ? input.issueContext.key_requirements
         : bodyParsed?.requirements ?? [];
+    // Include adjacent test files when the validation commands indicate a vitest run.
+    const expandedScope = expandScopeWithTestPaths(resolvedScope, resolvedValidation);
     const requirementLines = resolvedRequirements.map((r, i) => `   ${i + 1}. ${r}`);
     const bodyLines = input.issueContext?.body
         ? [`Issue description:\n${input.issueContext.body}`]
@@ -285,7 +364,7 @@ function compileImplPacket(input) {
         stateFile: input.stateFile,
         telemetryFile: input.telemetryFile,
         issueContext: input.issueContext,
-        allowedScope: resolvedScope,
+        allowedScope: expandedScope,
         validationCommands: resolvedValidation,
         mode: promptMode,
         simplicityMode: input.simplicityMode,
@@ -301,7 +380,7 @@ function compileImplPacket(input) {
         instructions: {
             primary_goal: promptResult.prompt,
             steps,
-            allowed_scope: resolvedScope,
+            allowed_scope: expandedScope,
             validation_commands: resolvedValidation,
             issue_context: input.issueContext,
         },

package/dist/medic/routing-signals.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Polaris routing anomaly → Medic/state-repair signal classification.
+ *
+ * These signals are emitted by the loop/dispatch/runtime boundary and are
+ * reviewed by Medic, not used to mutate routing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyRoutingTelemetryEvent = classifyRoutingTelemetryEvent;
+/**
+ * Map a raw telemetry event to a state-repair review signal.
+ *
+ * Only loop/dispatch boundary events that indicate runtime state-repair work
+ * are classified. The returned signal has occurrences=1 and a single child_id;
+ * consumers (such as SOL scoring) should aggregate by signal name.
+ */
+function classifyRoutingTelemetryEvent(event) {
+    const eventName = event["event"];
+    if (typeof eventName !== "string")
+        return undefined;
+    const childId = typeof event["child_id"] === "string" ? event["child_id"] : undefined;
+    const childIds = childId ? [childId] : [];
+    switch (eventName) {
+        case "sealed-result-read-error":
+            return {
+                signal: "missing-sealed-result",
+                reason: "missing-sealed-result",
+                occurrences: 1,
+                child_ids: childIds,
+            };
+        case "stale-dispatch-aborted":
+            return {
+                signal: "stale-dispatch-abort",
+                reason: "stale-dispatch-abort",
+                occurrences: 1,
+                child_ids: childIds,
+            };
+        case "invalid-inline-attempt":
+            return {
+                signal: "invalid-inline-attempt",
+                reason: "invalid-inline-attempt",
+                occurrences: 1,
+                child_ids: childIds,
+            };
+        case "child-recovery-initiated": {
+            const recoveryReason = event["recovery_reason"];
+            if (recoveryReason === "stale-dispatch") {
+                return {
+                    signal: "stale-dispatch-abort",
+                    reason: "stale-dispatch",
+                    occurrences: 1,
+                    child_ids: childIds,
+                };
+            }
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}

package/dist/qc/policy.js

@@ -59,6 +59,8 @@ function decideProviderFailureAction(reason, policy) {
             return policy?.timeout ?? "fail";
         case "parse-failed":
             return policy?.parseFailure ?? "fail";
+        case "rate-limited":
+            return policy?.rateLimited ?? "fail";
         default:
             return "fail";
     }