@lsctech/polaris 0.4.9 → 0.5.2

package/dist/autoresearch/gates.js

@@ -23,6 +23,7 @@ exports.gateValidationFailed = gateValidationFailed;
 exports.gateWorkerWentOutOfScope = gateWorkerWentOutOfScope;
 exports.gateForemanTokenBurnOverBudget = gateForemanTokenBurnOverBudget;
 exports.gateStateRepairRequired = gateStateRepairRequired;
+exports.gateQcBlockingFindings = gateQcBlockingFindings;
 exports.readJsonLines = readJsonLines;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -362,6 +363,51 @@ function safeReaddir(dir) {
         return [];
     }
 }
+/**
+ * qc-blocking-findings: Are there unresolved critical/high QC findings
+ * attributed to this cluster with high or medium confidence?
+ *
+ * Evidence: qcResults loaded from .polaris/clusters/<cluster-id>/qc/.
+ * Skipped when no QC artifacts exist.
+ *
+ * Only high/medium attribution-confidence findings are counted — provider noise
+ * (low/unattributed confidence) is excluded so workers are not penalized for
+ * external reviewer uncertainty.
+ */
+function gateQcBlockingFindings(artifacts) {
+    if (artifacts.qcResults.length === 0) {
+        return { gate: "qc-blocking-findings", outcome: "skipped", detail: "no QC artifacts found" };
+    }
+    let blockingCount = 0;
+    let weightedOpenScore = 0;
+    const severityWeights = { critical: 10, high: 5, medium: 2, low: 1, info: 0.5 };
+    const confidenceWeights = { high: 1.0, medium: 0.7, low: 0.3, unattributed: 0 };
+    for (const result of artifacts.qcResults) {
+        for (const finding of result.findings) {
+            const conf = finding.attribution.confidence;
+            const isOpenUnresolved = finding.status === "open" || finding.status === "follow-up";
+            if (isOpenUnresolved && conf !== "low" && conf !== "unattributed") {
+                weightedOpenScore += severityWeights[finding.severity] * confidenceWeights[conf];
+            }
+            if (conf === "low" || conf === "unattributed")
+                continue;
+            if (finding.status === "autofixed" || finding.status === "repaired" || finding.status === "waived")
+                continue;
+            if ((finding.severity === "critical" || finding.severity === "high") &&
+                (finding.status === "open" || finding.status === "follow-up")) {
+                blockingCount++;
+            }
+        }
+    }
+    if (blockingCount > 0) {
+        return {
+            gate: "qc-blocking-findings",
+            outcome: "failed",
+            detail: `${blockingCount} unresolved critical/high QC finding${blockingCount === 1 ? "" : "s"} with attributed confidence (weighted open score ${weightedOpenScore.toFixed(2)})`,
+        };
+    }
+    return { gate: "qc-blocking-findings", outcome: "passed" };
+}
 exports.ALL_GATES = [
     gateUserIntervened,
     gateForemanResentPacket,
@@ -371,4 +417,5 @@ exports.ALL_GATES = [
     gateWorkerWentOutOfScope,
     gateForemanTokenBurnOverBudget,
     gateStateRepairRequired,
+    gateQcBlockingFindings,
 ];

package/dist/autoresearch/proposal.js

@@ -10,6 +10,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FIX_ZONE_MAP = void 0;
+exports.buildQcProposals = buildQcProposals;
 exports.buildProposals = buildProposals;
 exports.loadDiagnosisReport = loadDiagnosisReport;
 exports.validateDiagnosisReport = validateDiagnosisReport;
@@ -50,6 +51,40 @@ exports.FIX_ZONE_MAP = {
         artifact_type: "medic-template",
         hint: "Medic artifacts detected — state repair was required. Review medic template heuristics and state-repair triggers.",
     },
+    "qc-blocking-findings": {
+        artifact_type: "scoring-rule",
+        hint: "Unresolved critical/high QC findings with attributed confidence. Review QC artifacts, triage open findings, and route repairs before delivery.",
+    },
+};
+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
@@ -58,6 +93,80 @@ exports.FIX_ZONE_MAP = {
  * Maps a DiagnosisReport's failed gates to AutresearchProposal objects.
  * Gates without a fix zone entry are skipped.
  */
+const QC_FIX_ZONE_MAP = {
+    "qc-recurring-provider": {
+        artifact_type: "provider-role-recommendation",
+        hint: "A QC provider is producing recurring attributed findings. Review provider capability mapping, role assignment, and confidence thresholds.",
+    },
+    "qc-recurring-child": {
+        artifact_type: "worker-template",
+        hint: "A child/worker route accumulates recurring QC findings. Tighten packet scope, validation commands, or acceptance criteria for this route.",
+    },
+    "qc-unvalidated-noise": {
+        artifact_type: "runtime-config",
+        hint: "A large share of QC findings are low/unattributed provider noise. Raise providerConfidenceThreshold or tighten QC provider selection.",
+    },
+    "qc-recurring-validation": {
+        artifact_type: "scoring-rule",
+        hint: "Unresolved QC findings indicate validation gaps. Strengthen scoring rules and repair routing before delivery.",
+    },
+    "qc-recurring-docs": {
+        artifact_type: "skill-prompt",
+        hint: "Recurring QC findings relate to documentation. Update skill prompts and worker instructions that produce docs artifacts.",
+    },
+};
+/**
+ * Builds QC-derived improvement proposals from the diagnosis report.
+ *
+ * These recommendations target config, provider, packet-scope, validation,
+ * and docs artifacts for recurring QC failure patterns.
+ */
+function buildQcProposals(report) {
+    const qc = report.qc_summary;
+    if (!qc)
+        return [];
+    const proposals = [];
+    const confidence = Math.max(0, Math.min(1, 1 - qc.qc_penalty));
+    const addProposal = (gateId, artifactType, hint) => {
+        proposals.push({
+            gate_id: gateId,
+            artifact_type: artifactType,
+            hint,
+            run_id: report.run_id,
+            evidence_run_ids: [report.run_id],
+            confidence,
+            fix_zone: `${artifactType}/${gateId}`,
+        });
+    };
+    // Recurring provider signal: multiple blocking findings from the same provider.
+    for (const [provider, summary] of Object.entries(qc.provider_breakdown)) {
+        if (summary.total >= 2 && summary.blocking > 0) {
+            addProposal(`qc-recurring-provider:${provider}`, "provider-role-recommendation", `Provider '${provider}' produced ${summary.blocking} blocking QC findings across ${summary.total} total findings. Review provider capability mapping, role assignment, and confidence thresholds.`);
+        }
+    }
+    // Recurring child/worker route signal: same child owns multiple findings.
+    for (const signal of qc.recurring_child_signals) {
+        if (signal.finding_count >= 2) {
+            addProposal(`qc-recurring-child:${signal.child_id}`, "worker-template", `Child '${signal.child_id}' accumulated ${signal.finding_count} attributed QC findings (weighted score ${signal.weighted_score.toFixed(2)}). Tighten packet scope, validation commands, or acceptance criteria for this worker route.`);
+        }
+    }
+    // High share of unvalidated/provider-noise findings.
+    const noiseRatio = qc.total_findings > 0 ? qc.unvalidated_findings / qc.total_findings : 0;
+    if (qc.unvalidated_findings >= 3 && noiseRatio > 0.3) {
+        addProposal("qc-unvalidated-noise", "runtime-config", `${qc.unvalidated_findings} of ${qc.total_findings} QC findings are low/unattributed provider noise. Raise providerConfidenceThreshold or tighten QC provider selection in runtime config.`);
+    }
+    // Unresolved blocking findings indicate a validation/routing gap.
+    if (qc.blocking_findings > 0 && qc.weighted_open_score > 0) {
+        addProposal("qc-recurring-validation", "scoring-rule", `${qc.blocking_findings} blocking QC findings remain unresolved (weighted score ${qc.weighted_open_score.toFixed(2)}). Strengthen validation gates and repair routing before delivery.`);
+    }
+    // Recurring docs-category findings.
+    for (const [category, summary] of Object.entries(qc.category_breakdown)) {
+        if (category === "docs" && summary.total >= 2) {
+            addProposal("qc-recurring-docs", "skill-prompt", `${summary.total} QC findings relate to documentation. Update skill prompts and worker instructions that produce docs artifacts.`);
+        }
+    }
+    return proposals;
+}
 function buildProposals(report) {
     const proposals = [];
     for (const gateId of report.failed_gates) {
@@ -74,6 +183,25 @@ function buildProposals(report) {
             fix_zone: `${entry.artifact_type}/${gateId}`,
         });
     }
+    proposals.push(...buildQcProposals(report));
+    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;
 }
 // ──────────────────────────────────────────────
@@ -96,6 +224,37 @@ function loadDiagnosisReport(filePath) {
     }
     return validateDiagnosisReport(raw);
 }
+function defaultRoutingBreakdown() {
+    return { original_worker: 0, repair_worker: 0, follow_up: 0, operator_review: 0, unset: 0 };
+}
+function normalizeQcScoreSummary(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const q = raw;
+    const zeroSeverity = { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
+    const rawOpen = q.open_by_severity && typeof q.open_by_severity === "object" && !Array.isArray(q.open_by_severity)
+        ? q.open_by_severity
+        : undefined;
+    const openBySeverity = rawOpen ? { ...zeroSeverity, ...rawOpen } : zeroSeverity;
+    return {
+        total_findings: q.total_findings ?? 0,
+        blocking_findings: q.blocking_findings ?? 0,
+        autofixed_findings: q.autofixed_findings ?? 0,
+        repaired_findings: q.repaired_findings ?? 0,
+        waived_findings: q.waived_findings ?? 0,
+        unvalidated_findings: q.unvalidated_findings ?? 0,
+        open_by_severity: openBySeverity,
+        weighted_open_score: q.weighted_open_score ?? 0,
+        qc_penalty: q.qc_penalty ?? 0,
+        blocks_delivery: q.blocks_delivery ?? false,
+        qc_run_count: q.qc_run_count ?? 0,
+        provider_breakdown: q.provider_breakdown ?? {},
+        routing_breakdown: q.routing_breakdown ?? defaultRoutingBreakdown(),
+        category_breakdown: q.category_breakdown ?? {},
+        recurring_child_signals: Array.isArray(q.recurring_child_signals) ? q.recurring_child_signals : [],
+        recurring_provider_signals: Array.isArray(q.recurring_provider_signals) ? q.recurring_provider_signals : [],
+    };
+}
 /**
  * Validates a parsed value against the DiagnosisReport schema.
  * Throws a descriptive error if required fields are missing or have wrong types.
@@ -117,5 +276,28 @@ 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: [],
+        };
+    const normalizedQcSummary = normalizeQcScoreSummary(r["qc_summary"]);
+    return {
+        ...raw,
+        router_outcomes: normalizedRouterOutcomes,
+        qc_summary: normalizedQcSummary,
+    };
 }

package/dist/autoresearch/score.js

@@ -19,9 +19,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadRunArtifacts = loadRunArtifacts;
 exports.computeScore = computeScore;
 exports.buildDiagnosisHints = buildDiagnosisHints;
+exports.computeQcSummary = computeQcSummary;
+exports.summarizeRouterOutcomes = summarizeRouterOutcomes;
 exports.scoreRun = scoreRun;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const artifacts_js_1 = require("../qc/artifacts.js");
 const gates_js_1 = require("./gates.js");
 // ──────────────────────────────────────────────
 // Diagnosis hints table
@@ -59,6 +62,10 @@ const HINTS = {
         fix_zone: "medic / cluster-state",
         hint: "Medic artifacts detected — state repair was required during this run. Review the medic chart and root cause.",
     },
+    "qc-blocking-findings": {
+        fix_zone: "qc / findings",
+        hint: "QC produced unresolved critical/high findings attributed to this run. Review QC artifacts, triage findings, and route repairs before delivery.",
+    },
 };
 // ──────────────────────────────────────────────
 // Artifact loader
@@ -95,6 +102,18 @@ function safeReaddir(dir) {
     }
 }
 const NON_WORKER_PREFIXES = ["librarian-", "CHART-", "medic-result-"];
+function loadQcArtifacts(clusterId, repoRoot) {
+    if (!clusterId)
+        return [];
+    const ids = (0, artifacts_js_1.listQcArtifactIds)(clusterId, repoRoot);
+    const results = [];
+    for (const id of ids) {
+        const result = (0, artifacts_js_1.readQcArtifact)(clusterId, id, repoRoot);
+        if (result)
+            results.push(result);
+    }
+    return results;
+}
 function readResultPackets(clusterDir) {
     if (!clusterDir)
         return [];
@@ -176,6 +195,7 @@ function loadRunArtifacts(repoRoot, runId) {
         // Legacy fallback: extract from result packet files
         workerResultContracts = extractWorkerResultContracts(resultPackets);
     }
+    const qcResults = loadQcArtifacts(clusterId, repoRoot);
     return {
         runId,
         runDir,
@@ -185,6 +205,7 @@ function loadRunArtifacts(repoRoot, runId) {
         resultPackets,
         workerResultContracts,
         telemetryEvents,
+        qcResults,
     };
 }
 // ──────────────────────────────────────────────
@@ -203,6 +224,257 @@ function buildDiagnosisHints(failedGateNames) {
         return { gate, ...h };
     });
 }
+const SEVERITY_WEIGHTS = {
+    critical: 10,
+    high: 5,
+    medium: 2,
+    low: 1,
+    info: 0.5,
+};
+const CONFIDENCE_WEIGHTS = {
+    high: 1.0,
+    medium: 0.7,
+    low: 0.3,
+    unattributed: 0,
+};
+function zeroCounts() {
+    return { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
+}
+function zeroRouting() {
+    return { original_worker: 0, repair_worker: 0, follow_up: 0, operator_review: 0, unset: 0 };
+}
+function computeQcPenalty(weightedOpenScore) {
+    // Soft penalty that grows with weighted severity but does not dominate the score.
+    return weightedOpenScore === 0 ? 0 : weightedOpenScore / (weightedOpenScore + 20);
+}
+/**
+ * Computes a QcScoreSummary from the QC results loaded for this run.
+ * Returns null when no QC results are present.
+ *
+ * A finding is "blocking" if:
+ *   - severity is critical or high
+ *   - status is "open" or "follow-up" (not autofixed, repaired, or waived)
+ *   - attribution confidence is "high" or "medium" (not unvalidated provider noise)
+ *
+ * Worker scoring intentionally does not penalize for "unvalidated" or
+ * "low" attribution-confidence findings — these are treated as provider noise.
+ *
+ * The weighted open score multiplies severity by attribution confidence so that
+ * a critical/high-confidence finding hurts SOL scoring more than a low-severity
+ * or uncertain finding.
+ */
+function computeQcSummary(qcResults) {
+    if (qcResults.length === 0)
+        return null;
+    let total = 0;
+    let blocking = 0;
+    let autofixed = 0;
+    let repaired = 0;
+    let waived = 0;
+    let unvalidated = 0;
+    const openBySeverity = zeroCounts();
+    let weightedOpenScore = 0;
+    let blocksDelivery = false;
+    const providerBreakdown = new Map();
+    const categoryBreakdown = new Map();
+    const routingBreakdown = zeroRouting();
+    const childScores = new Map();
+    const providerScores = new Map();
+    for (const result of qcResults) {
+        if (result.policyDecision.blocksDelivery)
+            blocksDelivery = true;
+        for (const finding of result.findings) {
+            total++;
+            const provider = result.provider;
+            const providerEntry = providerBreakdown.get(provider) ?? { total: 0, blocking: 0, unvalidated: 0 };
+            providerEntry.total += 1;
+            providerBreakdown.set(provider, providerEntry);
+            const category = (finding.category ?? "uncategorized").toLowerCase();
+            const categoryEntry = categoryBreakdown.get(category) ?? { total: 0, blocking: 0 };
+            categoryEntry.total += 1;
+            const routing = finding.routingDecision ?? "unset";
+            if (routing === "original-worker")
+                routingBreakdown.original_worker += 1;
+            else if (routing === "repair-worker")
+                routingBreakdown.repair_worker += 1;
+            else if (routing === "follow-up")
+                routingBreakdown.follow_up += 1;
+            else if (routing === "operator-review")
+                routingBreakdown.operator_review += 1;
+            else
+                routingBreakdown.unset += 1;
+            const conf = finding.attribution.confidence;
+            const isUnvalidated = conf === "low" || conf === "unattributed";
+            if (isUnvalidated) {
+                unvalidated++;
+                providerEntry.unvalidated += 1;
+                categoryBreakdown.set(category, categoryEntry);
+                continue; // do not count provider noise toward any negative bucket
+            }
+            if (finding.status === "autofixed") {
+                autofixed++;
+                categoryBreakdown.set(category, categoryEntry);
+                continue;
+            }
+            if (finding.status === "repaired") {
+                repaired++;
+                categoryBreakdown.set(category, categoryEntry);
+                continue;
+            }
+            if (finding.status === "waived") {
+                waived++;
+                categoryBreakdown.set(category, categoryEntry);
+                continue;
+            }
+            // "open" or "follow-up" — count toward open_by_severity and weighted score
+            const sev = finding.severity;
+            if (sev in openBySeverity)
+                openBySeverity[sev]++;
+            const isBlocking = (sev === "critical" || sev === "high") &&
+                (finding.status === "open" || finding.status === "follow-up");
+            if (isBlocking) {
+                blocking++;
+                categoryEntry.blocking += 1;
+                providerEntry.blocking += 1;
+            }
+            const findingWeight = SEVERITY_WEIGHTS[sev] * CONFIDENCE_WEIGHTS[conf];
+            weightedOpenScore += findingWeight;
+            const childId = finding.attribution.childId;
+            if (childId) {
+                const childEntry = childScores.get(childId) ?? { weighted_score: 0, finding_count: 0 };
+                childEntry.weighted_score += findingWeight;
+                childEntry.finding_count += 1;
+                childScores.set(childId, childEntry);
+            }
+            const providerScoreEntry = providerScores.get(provider) ?? { weighted_score: 0, finding_count: 0 };
+            providerScoreEntry.weighted_score += findingWeight;
+            providerScoreEntry.finding_count += 1;
+            providerScores.set(provider, providerScoreEntry);
+            categoryBreakdown.set(category, categoryEntry);
+            providerBreakdown.set(provider, providerEntry);
+        }
+    }
+    const recurringChildSignals = Array.from(childScores.entries())
+        .map(([child_id, value]) => ({ child_id, ...value }))
+        .filter((s) => s.weighted_score > 0)
+        .sort((a, b) => b.weighted_score - a.weighted_score || a.child_id.localeCompare(b.child_id));
+    const recurringProviderSignals = Array.from(providerScores.entries())
+        .map(([provider, value]) => ({ provider, ...value }))
+        .filter((s) => s.weighted_score > 0)
+        .sort((a, b) => b.weighted_score - a.weighted_score || a.provider.localeCompare(b.provider));
+    return {
+        total_findings: total,
+        blocking_findings: blocking,
+        autofixed_findings: autofixed,
+        repaired_findings: repaired,
+        waived_findings: waived,
+        unvalidated_findings: unvalidated,
+        open_by_severity: openBySeverity,
+        weighted_open_score: Number(weightedOpenScore.toFixed(3)),
+        qc_penalty: Number(computeQcPenalty(weightedOpenScore).toFixed(4)),
+        blocks_delivery: blocksDelivery,
+        qc_run_count: qcResults.length,
+        provider_breakdown: Object.fromEntries(providerBreakdown),
+        routing_breakdown: routingBreakdown,
+        category_breakdown: Object.fromEntries(categoryBreakdown),
+        recurring_child_signals: recurringChildSignals,
+        recurring_provider_signals: recurringProviderSignals,
+    };
+}
+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 +484,8 @@ 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 qcSummary = computeQcSummary(artifacts.qcResults);
     const clusterId = artifacts.currentState &&
         typeof artifacts.currentState === "object" &&
         !Array.isArray(artifacts.currentState)
@@ -225,5 +499,7 @@ function scoreRun(repoRoot, runId) {
         failed_gates: failedGates,
         score,
         diagnosis_hints: diagnosisHints,
+        router_outcomes: routerOutcomes,
+        qc_summary: qcSummary,
     };
 }

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);
 }