@lsctech/polaris 0.4.8 → 0.5.0

package/dist/autoresearch/proposal.js

@@ -51,6 +51,36 @@ exports.FIX_ZONE_MAP = {
         hint: "Medic artifacts detected — state repair was required. Review medic template heuristics and state-repair triggers.",
     },
 };
+const ROUTER_FAILURE_FIX_ZONE_MAP = {
+    "quota-exhausted": {
+        artifact_type: "runtime-config",
+        hint: "Recurring provider quota exhaustion detected. Adjust quota policy and fallback order in execution.routerPolicy, and document expected quota behavior for operators.",
+    },
+    "capability-mismatch": {
+        artifact_type: "provider-role-recommendation",
+        hint: "Recurring capability mismatch detected. Update provider capability metadata and role task-type mapping, and document role expectations.",
+    },
+    "trust-too-low": {
+        artifact_type: "provider-role-recommendation",
+        hint: "Recurring trust-tier mismatch detected. Update trust policy thresholds or provider trust metadata, and document trust requirements for worker routing.",
+    },
+    "no-slot": {
+        artifact_type: "runtime-config",
+        hint: "Recurring slot exhaustion detected. Tune worker pool slot limits and provider slot caps in router policy.",
+    },
+    "cost-policy": {
+        artifact_type: "runtime-config",
+        hint: "Recurring cost policy rejection detected. Revisit max cost tier and quota policies in router constraints.",
+    },
+    "not-in-policy": {
+        artifact_type: "provider-role-recommendation",
+        hint: "Recurring provider policy mismatch detected. Align rotation/providers with role policy allowlists and update routing docs.",
+    },
+    "role-disabled": {
+        artifact_type: "runtime-config",
+        hint: "Worker role is repeatedly disabled by policy. Update providerPolicy.worker and role routing defaults.",
+    },
+};
 // ──────────────────────────────────────────────
 // Build proposals from a DiagnosisReport
 // ──────────────────────────────────────────────
@@ -74,6 +104,24 @@ function buildProposals(report) {
             fix_zone: `${entry.artifact_type}/${gateId}`,
         });
     }
+    const recurringRouterFailures = report.router_outcomes?.recurring_failures ?? [];
+    for (const failure of recurringRouterFailures) {
+        if (failure.occurrences < 2)
+            continue;
+        const entry = ROUTER_FAILURE_FIX_ZONE_MAP[failure.reason] ?? {
+            artifact_type: "runtime-config",
+            hint: "Recurring router failure detected. Review router policy configuration and fallback behavior.",
+        };
+        proposals.push({
+            gate_id: `router-failure:${failure.reason}`,
+            artifact_type: entry.artifact_type,
+            hint: `${entry.hint} Observed ${failure.occurrences} times across children: ${failure.child_ids.join(", ") || "unknown"}.`,
+            run_id: report.run_id,
+            evidence_run_ids: [report.run_id],
+            confidence: report.score,
+            fix_zone: `${entry.artifact_type}/router-failure-${failure.reason}`,
+        });
+    }
     return proposals;
 }
 // ──────────────────────────────────────────────
@@ -117,5 +165,26 @@ function validateDiagnosisReport(raw) {
         throw new Error("Diagnosis report missing required number field: score");
     if (!Array.isArray(r["diagnosis_hints"]))
         throw new Error("Diagnosis report missing required array field: diagnosis_hints");
-    return raw;
+    const routerOutcomesRaw = r["router_outcomes"];
+    const normalizedRouterOutcomes = routerOutcomesRaw && typeof routerOutcomesRaw === "object"
+        ? {
+            total_decisions: typeof routerOutcomesRaw["total_decisions"] === "number" ? routerOutcomesRaw["total_decisions"] : 0,
+            exhausted_decisions: typeof routerOutcomesRaw["exhausted_decisions"] === "number" ? routerOutcomesRaw["exhausted_decisions"] : 0,
+            fallback_attempts: typeof routerOutcomesRaw["fallback_attempts"] === "number" ? routerOutcomesRaw["fallback_attempts"] : 0,
+            successful_fallbacks: typeof routerOutcomesRaw["successful_fallbacks"] === "number" ? routerOutcomesRaw["successful_fallbacks"] : 0,
+            recurring_failures: Array.isArray(routerOutcomesRaw["recurring_failures"])
+                ? routerOutcomesRaw["recurring_failures"]
+                : [],
+        }
+        : {
+            total_decisions: 0,
+            exhausted_decisions: 0,
+            fallback_attempts: 0,
+            successful_fallbacks: 0,
+            recurring_failures: [],
+        };
+    return {
+        ...raw,
+        router_outcomes: normalizedRouterOutcomes,
+    };
 }

package/dist/autoresearch/score.js

@@ -19,6 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadRunArtifacts = loadRunArtifacts;
 exports.computeScore = computeScore;
 exports.buildDiagnosisHints = buildDiagnosisHints;
+exports.summarizeRouterOutcomes = summarizeRouterOutcomes;
 exports.scoreRun = scoreRun;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -203,6 +204,100 @@ function buildDiagnosisHints(failedGateNames) {
         return { gate, ...h };
     });
 }
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === "string");
+}
+function summarizeRouterOutcomes(artifacts) {
+    const telemetry = artifacts.telemetryEvents
+        .map((event) => asRecord(event))
+        .filter((event) => event !== undefined);
+    const childCompletionStatus = new Map();
+    for (const event of telemetry) {
+        if (event["event"] !== "child-complete" || typeof event["child_id"] !== "string")
+            continue;
+        const completionStatus = typeof event["completion_status"] === "string"
+            ? event["completion_status"]
+            : "done";
+        childCompletionStatus.set(event["child_id"], completionStatus);
+    }
+    const selectedEvents = telemetry.filter((event) => event["event"] === "provider-selected");
+    const exhaustedEvents = telemetry.filter((event) => event["event"] === "provider-exhausted");
+    const fallbackEvents = telemetry.filter((event) => event["event"] === "provider-fallback-attempted");
+    const reasonCounts = new Map();
+    const countReason = (reason, childId) => {
+        const current = reasonCounts.get(reason) ?? { count: 0, childIds: new Set() };
+        current.count += 1;
+        if (childId)
+            current.childIds.add(childId);
+        reasonCounts.set(reason, current);
+    };
+    for (const event of exhaustedEvents) {
+        const reason = typeof event["reason"] === "string" ? event["reason"] : "no-provider-selected";
+        const childId = typeof event["child_id"] === "string" ? event["child_id"] : undefined;
+        countReason(reason, childId);
+    }
+    for (const event of selectedEvents) {
+        const childId = typeof event["child_id"] === "string" ? event["child_id"] : undefined;
+        const selectedProvider = typeof event["selected_provider"] === "string" ? event["selected_provider"] : null;
+        if (!selectedProvider) {
+            // Use per-candidate rejection reasons when available; fall back to the
+            // overall exhausted reason. Counting both for the same event would
+            // double-count shared reason strings (e.g. "no-slot").
+            const candidates = Array.isArray(event["router_candidates"]) ? event["router_candidates"] : [];
+            if (candidates.length > 0) {
+                for (const candidateRaw of candidates) {
+                    const candidate = asRecord(candidateRaw);
+                    if (!candidate)
+                        continue;
+                    const rejectionReasons = asStringArray(candidate["rejection_reasons"]);
+                    for (const reason of rejectionReasons) {
+                        countReason(reason, childId);
+                    }
+                }
+            }
+            else {
+                const exhaustedReason = typeof event["router_exhausted_reason"] === "string"
+                    ? event["router_exhausted_reason"]
+                    : "no-provider-selected";
+                countReason(exhaustedReason, childId);
+            }
+        }
+    }
+    let successfulFallbacks = 0;
+    for (const event of selectedEvents) {
+        const selectedProvider = typeof event["selected_provider"] === "string" ? event["selected_provider"] : null;
+        const providersTried = asStringArray(event["providers_tried"]);
+        const usedFallback = selectedProvider !== null && providersTried.length > 1;
+        if (!usedFallback)
+            continue;
+        const childId = typeof event["child_id"] === "string" ? event["child_id"] : undefined;
+        const completionStatus = childId ? childCompletionStatus.get(childId) : undefined;
+        if (completionStatus && completionStatus !== "blocked" && completionStatus !== "error") {
+            successfulFallbacks += 1;
+        }
+    }
+    const recurringFailures = Array.from(reasonCounts.entries())
+        .map(([reason, value]) => ({
+        reason,
+        occurrences: value.count,
+        child_ids: Array.from(value.childIds).sort(),
+    }))
+        .sort((a, b) => b.occurrences - a.occurrences || a.reason.localeCompare(b.reason));
+    return {
+        total_decisions: selectedEvents.length,
+        exhausted_decisions: exhaustedEvents.length,
+        fallback_attempts: fallbackEvents.length,
+        successful_fallbacks: successfulFallbacks,
+        recurring_failures: recurringFailures,
+    };
+}
 // ──────────────────────────────────────────────
 // Main entry point
 // ──────────────────────────────────────────────
@@ -212,6 +307,7 @@ function scoreRun(repoRoot, runId) {
     const failedGates = gateResults.filter((g) => g.outcome === "failed").map((g) => g.gate);
     const score = computeScore(gateResults);
     const diagnosisHints = buildDiagnosisHints(failedGates);
+    const routerOutcomes = summarizeRouterOutcomes(artifacts);
     const clusterId = artifacts.currentState &&
         typeof artifacts.currentState === "object" &&
         !Array.isArray(artifacts.currentState)
@@ -225,5 +321,6 @@ function scoreRun(repoRoot, runId) {
         failed_gates: failedGates,
         score,
         diagnosis_hints: diagnosisHints,
+        router_outcomes: routerOutcomes,
     };
 }

package/dist/cli/init.js

@@ -36,6 +36,13 @@ const PLAN_COMPLETE_STATUSES = new Set(["completed", "skipped"]);
 const ADOPTION_LOCKED_EXECUTION = {
     rotation: [],
     allowCrossAgentFallback: false,
+    routerPolicy: {
+        defaultWorkerPool: {
+            maxActiveWorkers: 1,
+            maxActiveSlots: 1,
+        },
+        allowCrossProviderFallback: false,
+    },
     adapter: "terminal-cli",
 };
 const ADOPTION_LOCKED_ORCHESTRATION = {
@@ -65,9 +72,19 @@ function asRecord(value) {
 function isAdoptionConfigLocked(existing) {
     const execution = asRecord(existing.execution);
     const orchestration = asRecord(existing.orchestration);
+    const routerPolicy = asRecord(execution.routerPolicy);
+    const defaultWorkerPool = asRecord(routerPolicy.defaultWorkerPool);
+    const routerPolicyMatches = Object.keys(routerPolicy).length === 0 ||
+        (routerPolicy.allowCrossProviderFallback ===
+            ADOPTION_LOCKED_EXECUTION.routerPolicy.allowCrossProviderFallback &&
+            defaultWorkerPool.maxActiveWorkers ===
+                ADOPTION_LOCKED_EXECUTION.routerPolicy.defaultWorkerPool.maxActiveWorkers &&
+            defaultWorkerPool.maxActiveSlots ===
+                ADOPTION_LOCKED_EXECUTION.routerPolicy.defaultWorkerPool.maxActiveSlots);
     return (Array.isArray(execution.rotation) &&
         execution.rotation.length === 0 &&
         execution.allowCrossAgentFallback === false &&
+        routerPolicyMatches &&
         execution.adapter === ADOPTION_LOCKED_EXECUTION.adapter &&
         orchestration.mode === ADOPTION_LOCKED_ORCHESTRATION.mode);
 }

package/dist/cluster-state/store.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeClusterState = exports.writeClusterStateSync = exports.writeClusterState = exports.readClusterStateSync = exports.readClusterState = void 0;
+exports.pruneExpiredClaims = pruneExpiredClaims;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const local_graph_1 = require("../tracker/local-graph");
@@ -44,6 +45,40 @@ const normalizeClusterState = (state) => ({
     ...state,
     tracker_mutations: state.tracker_mutations ?? {},
 });
+function pruneExpiredClaims(state, now = new Date()) {
+    const nowMs = now.getTime();
+    const expiredChildIds = [];
+    const nextClaimMetadata = {};
+    for (const [childId, claim] of Object.entries(state.claim_metadata ?? {})) {
+        const expiresAtMs = new Date(claim.expires_at).getTime();
+        const active = Number.isFinite(expiresAtMs) && expiresAtMs > nowMs;
+        if (active) {
+            nextClaimMetadata[childId] = claim;
+            continue;
+        }
+        expiredChildIds.push(childId);
+    }
+    if (expiredChildIds.length === 0) {
+        return { state, expiredChildIds };
+    }
+    const expiredSet = new Set(expiredChildIds);
+    const recoverableStatuses = new Set(["claimed", "dispatched", "running"]);
+    const child_states = state.child_states.map((child) => {
+        if (!expiredSet.has(child.id) || !recoverableStatuses.has(child.status)) {
+            return child;
+        }
+        return { ...child, status: "ready" };
+    });
+    return {
+        state: {
+            ...state,
+            state_generation: state.state_generation + 1,
+            claim_metadata: nextClaimMetadata,
+            child_states,
+        },
+        expiredChildIds,
+    };
+}
 const readClusterState = async (clusterId, repoRoot) => {
     const filePath = getClusterStatePath(clusterId, repoRoot);
     try {

package/dist/config/defaults.js

@@ -39,6 +39,14 @@ exports.DEFAULT_CONFIG = {
         rotation: [],
         allowCrossAgentFallback: false,
         roles: {},
+        routerPolicy: {
+            defaultWorkerPool: {
+                maxActiveWorkers: 1,
+                maxActiveSlots: 1,
+            },
+            providerRegistry: {},
+            allowCrossProviderFallback: false,
+        },
     },
     finalize: {
         targetBranch: "main",

package/dist/config/validator.js

@@ -7,6 +7,9 @@ function isPlainObject(value) {
 function isNumber(value) {
     return typeof value === "number" && !Number.isNaN(value);
 }
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && Number(value) > 0;
+}
 function isString(value) {
     return typeof value === "string";
 }
@@ -44,6 +47,29 @@ const SUPPORTED_EXECUTION_ADAPTERS = [
     "remote-worker",
     "cross-agent",
 ];
+const SUPPORTED_ROUTER_CAPABILITIES = [
+    "orchestration",
+    "analysis",
+    "implementation",
+    "repair",
+    "docs",
+    "finalization",
+];
+const SUPPORTED_ROUTER_TASK_TYPES = [
+    "startup",
+    "analyze",
+    "impl",
+    "repair",
+    "docs",
+    "finalize",
+];
+const SUPPORTED_ROUTER_TRUST_TIERS = ["sandbox", "standard", "trusted"];
+const SUPPORTED_ROUTER_COST_TIERS = ["low", "medium", "high"];
+const SUPPORTED_ROUTER_QUOTA_POLICIES = [
+    "best-effort",
+    "rate-limited",
+    "reserved",
+];
 const SUPPORTED_LIFECYCLE_STATES = [
     "backlog",
     "in_progress",
@@ -325,6 +351,126 @@ function validateConfig(config) {
                     }
                 }
             }
+            if ("routerPolicy" in config.execution && config.execution.routerPolicy !== undefined) {
+                if (!isPlainObject(config.execution.routerPolicy)) {
+                    result.valid = false;
+                    result.errors.push("execution.routerPolicy must be a plain object");
+                }
+                else {
+                    const routerPolicy = config.execution.routerPolicy;
+                    const providerKeys = isPlainObject(config.execution.providers)
+                        ? new Set(Object.keys(config.execution.providers))
+                        : null;
+                    if ("allowCrossProviderFallback" in routerPolicy &&
+                        routerPolicy.allowCrossProviderFallback !== undefined &&
+                        !isBoolean(routerPolicy.allowCrossProviderFallback)) {
+                        result.valid = false;
+                        result.errors.push("execution.routerPolicy.allowCrossProviderFallback must be a boolean");
+                    }
+                    if (isBoolean(config.execution.allowCrossAgentFallback) &&
+                        isBoolean(routerPolicy.allowCrossProviderFallback) &&
+                        config.execution.allowCrossAgentFallback !== routerPolicy.allowCrossProviderFallback) {
+                        result.valid = false;
+                        result.errors.push("execution fallback policy is ambiguous: allowCrossAgentFallback conflicts with execution.routerPolicy.allowCrossProviderFallback");
+                    }
+                    if ("defaultWorkerPool" in routerPolicy && routerPolicy.defaultWorkerPool !== undefined) {
+                        if (!isPlainObject(routerPolicy.defaultWorkerPool)) {
+                            result.valid = false;
+                            result.errors.push("execution.routerPolicy.defaultWorkerPool must be a plain object");
+                        }
+                        else {
+                            if ("maxActiveWorkers" in routerPolicy.defaultWorkerPool &&
+                                routerPolicy.defaultWorkerPool.maxActiveWorkers !== undefined &&
+                                !isPositiveInteger(routerPolicy.defaultWorkerPool.maxActiveWorkers)) {
+                                result.valid = false;
+                                result.errors.push("execution.routerPolicy.defaultWorkerPool.maxActiveWorkers must be a positive integer");
+                            }
+                            if ("maxActiveSlots" in routerPolicy.defaultWorkerPool &&
+                                routerPolicy.defaultWorkerPool.maxActiveSlots !== undefined &&
+                                !isPositiveInteger(routerPolicy.defaultWorkerPool.maxActiveSlots)) {
+                                result.valid = false;
+                                result.errors.push("execution.routerPolicy.defaultWorkerPool.maxActiveSlots must be a positive integer");
+                            }
+                        }
+                    }
+                    if ("providerRegistry" in routerPolicy && routerPolicy.providerRegistry !== undefined) {
+                        if (!isPlainObject(routerPolicy.providerRegistry)) {
+                            result.valid = false;
+                            result.errors.push("execution.routerPolicy.providerRegistry must be a plain object");
+                        }
+                        else {
+                            for (const [providerName, providerPolicy] of Object.entries(routerPolicy.providerRegistry)) {
+                                if (providerKeys && !providerKeys.has(providerName)) {
+                                    result.valid = false;
+                                    result.errors.push(`execution.routerPolicy.providerRegistry contains unknown provider: ${providerName}`);
+                                }
+                                if (!isPlainObject(providerPolicy)) {
+                                    result.valid = false;
+                                    result.errors.push(`execution.routerPolicy.providerRegistry.${providerName} must be a plain object`);
+                                    continue;
+                                }
+                                if ("eligibleRoles" in providerPolicy && providerPolicy.eligibleRoles !== undefined) {
+                                    if (!Array.isArray(providerPolicy.eligibleRoles) ||
+                                        !providerPolicy.eligibleRoles.every((role) => isString(role) &&
+                                            SUPPORTED_EXECUTION_ROLES.includes(role))) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.eligibleRoles must contain only supported execution roles`);
+                                    }
+                                }
+                                if ("capabilities" in providerPolicy && providerPolicy.capabilities !== undefined) {
+                                    if (!Array.isArray(providerPolicy.capabilities) ||
+                                        !providerPolicy.capabilities.every((capability) => isString(capability) &&
+                                            SUPPORTED_ROUTER_CAPABILITIES.includes(capability))) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.capabilities must contain only: orchestration, analysis, implementation, repair, docs, finalization`);
+                                    }
+                                }
+                                if ("taskTypes" in providerPolicy && providerPolicy.taskTypes !== undefined) {
+                                    if (!Array.isArray(providerPolicy.taskTypes) ||
+                                        !providerPolicy.taskTypes.every((taskType) => isString(taskType) &&
+                                            SUPPORTED_ROUTER_TASK_TYPES.includes(taskType))) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.taskTypes must contain only: startup, analyze, impl, repair, docs, finalize`);
+                                    }
+                                }
+                                if ("trustTier" in providerPolicy && providerPolicy.trustTier !== undefined) {
+                                    if (!isString(providerPolicy.trustTier) ||
+                                        !SUPPORTED_ROUTER_TRUST_TIERS.includes(providerPolicy.trustTier)) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.trustTier must be one of: sandbox, standard, trusted`);
+                                    }
+                                }
+                                if ("costTier" in providerPolicy && providerPolicy.costTier !== undefined) {
+                                    if (!isString(providerPolicy.costTier) ||
+                                        !SUPPORTED_ROUTER_COST_TIERS.includes(providerPolicy.costTier)) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.costTier must be one of: low, medium, high`);
+                                    }
+                                }
+                                if ("quotaPolicy" in providerPolicy && providerPolicy.quotaPolicy !== undefined) {
+                                    if (!isString(providerPolicy.quotaPolicy) ||
+                                        !SUPPORTED_ROUTER_QUOTA_POLICIES.includes(providerPolicy.quotaPolicy)) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.quotaPolicy must be one of: best-effort, rate-limited, reserved`);
+                                    }
+                                }
+                                if ("fallbackEligible" in providerPolicy &&
+                                    providerPolicy.fallbackEligible !== undefined &&
+                                    !isBoolean(providerPolicy.fallbackEligible)) {
+                                    result.valid = false;
+                                    result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.fallbackEligible must be a boolean`);
+                                }
+                                if ("maxActiveSlots" in providerPolicy &&
+                                    providerPolicy.maxActiveSlots !== undefined &&
+                                    !isPositiveInteger(providerPolicy.maxActiveSlots)) {
+                                    result.valid = false;
+                                    result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.maxActiveSlots must be a positive integer`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
     // finalize

package/dist/loop/adapters/agent-subtask.js

@@ -50,6 +50,7 @@ class AgentSubtaskAdapter {
         const label = packet.active_child || ((0, worker_packet_js_1.isWorkerPacket)(packet) ? packet.worker_role : 'worker');
         const commandRun = `agent-subtask:${label}`;
         const provider = options.provider || "agent-subtask";
+        const routerEvidence = options.routerDecision;
         if (!this.dispatcher) {
             const error = "Native ephemeral agent subtask dispatch is unavailable in this host environment. " +
                 "Use manual handoff or a configured terminal-cli adapter.";
@@ -60,6 +61,10 @@ class AgentSubtaskAdapter {
                 command_run: commandRun,
                 summary: error,
                 stderr: error,
+                failure_origin: "provider-launch",
+                failure_category: "provider-unavailable",
+                fallback_eligible: true,
+                router_evidence: routerEvidence,
             };
         }
         if ((0, worker_packet_js_1.isWorkerPacket)(packet) && packet.worker_role === 'impl') {
@@ -78,6 +83,10 @@ class AgentSubtaskAdapter {
                         warnings: ["empty-allowed-scope"],
                     }),
                     stderr: blockedMsg,
+                    failure_origin: "provider-launch",
+                    failure_category: "launch-error",
+                    fallback_eligible: false,
+                    router_evidence: routerEvidence,
                 };
             }
         }
@@ -94,6 +103,7 @@ class AgentSubtaskAdapter {
                     next_action: "resume-parent",
                     warnings: ["dry-run"],
                 }),
+                router_evidence: routerEvidence,
             };
         }
         const instructions = (0, worker_instructions_js_1.buildWorkerInstructions)(packet);
@@ -113,6 +123,10 @@ class AgentSubtaskAdapter {
                     command_run: commandRun,
                     summary: validationError,
                     stderr: validationError,
+                    failure_origin: "worker-execution",
+                    failure_category: "worker-failure",
+                    fallback_eligible: false,
+                    router_evidence: routerEvidence,
                 };
             }
             return {
@@ -120,6 +134,7 @@ class AgentSubtaskAdapter {
                 provider_used: provider,
                 command_run: commandRun,
                 summary,
+                router_evidence: routerEvidence,
             };
         }
         catch (err) {
@@ -130,6 +145,10 @@ class AgentSubtaskAdapter {
                 command_run: commandRun,
                 summary: `Native ephemeral agent subtask dispatch failed: ${msg}`,
                 stderr: msg,
+                failure_origin: "worker-execution",
+                failure_category: "worker-failure",
+                fallback_eligible: false,
+                router_evidence: routerEvidence,
             };
         }
     }