@lsctech/polaris 0.5.6 → 0.5.7

package/dist/autoresearch/proposal.js

@@ -253,6 +253,11 @@ function normalizeQcScoreSummary(raw) {
         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 : [],
+        repair_loop: q.repair_loop ?? null,
+        noisy_providers: Array.isArray(q.noisy_providers) ? q.noisy_providers : [],
+        has_repair_failures: q.has_repair_failures ?? false,
+        unresolved_high_severity: q.unresolved_high_severity ?? 0,
+        max_round_exhausted: q.max_round_exhausted ?? false,
     };
 }
 /**

package/dist/autoresearch/score.js

@@ -25,6 +25,7 @@ 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 store_js_1 = require("../cluster-state/store.js");
 const gates_js_1 = require("./gates.js");
 // ──────────────────────────────────────────────
 // Diagnosis hints table
@@ -196,6 +197,7 @@ function loadRunArtifacts(repoRoot, runId) {
         workerResultContracts = extractWorkerResultContracts(resultPackets);
     }
     const qcResults = loadQcArtifacts(clusterId, repoRoot);
+    const clusterState = clusterId ? (0, store_js_1.readClusterStateSync)(clusterId, repoRoot) : null;
     return {
         runId,
         runDir,
@@ -206,6 +208,7 @@ function loadRunArtifacts(repoRoot, runId) {
         workerResultContracts,
         telemetryEvents,
         qcResults,
+        clusterState,
     };
 }
 // ──────────────────────────────────────────────
@@ -247,6 +250,159 @@ function computeQcPenalty(weightedOpenScore) {
     // Soft penalty that grows with weighted severity but does not dominate the score.
     return weightedOpenScore === 0 ? 0 : weightedOpenScore / (weightedOpenScore + 20);
 }
+function zeroProviderAttemptSummary() {
+    return { total: 0, success: 0, failure: 0, fallback: 0, skipped: 0, all_providers_failed: false };
+}
+function zeroRepairLoopSummary() {
+    return {
+        status: "not-configured",
+        rounds_completed: 0,
+        max_rounds: 0,
+        packets_compiled: 0,
+        packets_completed: 0,
+        packets_failed: 0,
+        rerun_outcome: null,
+        provider_attempts: zeroProviderAttemptSummary(),
+    };
+}
+function mapTerminalOutcome(outcome) {
+    switch (outcome) {
+        case "pass":
+            return "passed";
+        case "no-repairable":
+            return "no-repairable";
+        case "max-rounds":
+            return "max-rounds";
+        case "all-providers-failed":
+            return "all-providers-failed";
+        case "operator-review":
+            return "operator-review";
+        case "medic-referral":
+            return "medic-referral";
+        case "qc-disabled":
+            return "not-configured";
+        default:
+            return "unknown";
+    }
+}
+function providerAttemptStatusFromResult(result) {
+    if (result.providerAttempt)
+        return result.providerAttempt.status;
+    if (result.allProvidersFailed || result.status === "failed")
+        return "failure";
+    if (result.status === "skipped")
+        return "skipped";
+    if (result.findings.length > 0 || result.status === "findings" || result.status === "blocked")
+        return "success";
+    if (result.status === "passed")
+        return "success";
+    return undefined;
+}
+function computeProviderAttemptSummary(qcResults, telemetryEvents) {
+    const summary = zeroProviderAttemptSummary();
+    for (const result of qcResults) {
+        const status = providerAttemptStatusFromResult(result);
+        if (status) {
+            summary.total += 1;
+            if (status === "success")
+                summary.success += 1;
+            else if (status === "failure")
+                summary.failure += 1;
+            else if (status === "fallback")
+                summary.fallback += 1;
+            else if (status === "skipped")
+                summary.skipped += 1;
+        }
+        if (result.allProvidersFailed)
+            summary.all_providers_failed = true;
+    }
+    // Telemetry fallback events augment the fallback count when providerAttempt was not written.
+    for (const ev of telemetryEvents) {
+        const rec = asRecord(ev);
+        if (rec?.["event"] === "provider-fallback-attempted")
+            summary.fallback += 1;
+    }
+    return summary;
+}
+function computeQcRepairLoopSummary(qcResults, clusterState, telemetryEvents, currentState) {
+    if (qcResults.length === 0)
+        return zeroRepairLoopSummary();
+    const currentStateRec = asRecord(currentState);
+    const loopState = currentStateRec?.["qc_repair_loop"];
+    const terminalOutcome = clusterState?.qc_repair_outcome ??
+        (loopState?.terminal_outcome ? String(loopState.terminal_outcome) : null);
+    const terminalEvents = telemetryEvents
+        .map(asRecord)
+        .filter((e) => e !== undefined && e["event"] === "qc-repair-loop-terminal");
+    const lastTerminal = terminalEvents[terminalEvents.length - 1];
+    const manifestEvents = telemetryEvents
+        .map(asRecord)
+        .filter((e) => e !== undefined && e["event"] === "qc-repair-manifest-compiled");
+    const failureEvents = telemetryEvents
+        .map(asRecord)
+        .filter((e) => e !== undefined && e["event"] === "qc-repair-worker-failures");
+    const failedPacketIds = new Set();
+    for (const ev of failureEvents) {
+        const ids = ev["failed_packet_ids"];
+        if (Array.isArray(ids)) {
+            for (const id of ids) {
+                if (typeof id === "string")
+                    failedPacketIds.add(id);
+            }
+        }
+    }
+    const rerunEvents = telemetryEvents
+        .map(asRecord)
+        .filter((e) => e !== undefined && e["event"] === "qc-repair-rerun-complete");
+    const lastRerun = rerunEvents[rerunEvents.length - 1];
+    let status;
+    if (terminalOutcome) {
+        status = mapTerminalOutcome(terminalOutcome);
+    }
+    else if (lastTerminal) {
+        status = mapTerminalOutcome(asString(lastTerminal["outcome"]));
+    }
+    else if (loopState) {
+        status = "in-progress";
+    }
+    else {
+        status = "not-run";
+    }
+    const roundsCompleted = asNumber(lastTerminal?.["rounds_completed"]) ??
+        (loopState?.current_round ?? 0);
+    const maxRounds = asNumber(lastTerminal?.["max_rounds"]) ??
+        (loopState?.max_rounds ?? 0);
+    const packetsCompiled = manifestEvents.reduce((sum, e) => {
+        const n = asNumber(e["packet_count"]);
+        return sum + (n ?? 0);
+    }, 0);
+    const packetsFailed = failedPacketIds.size;
+    const packetsCompleted = status === "not-run" || status === "not-configured"
+        ? 0
+        : Math.max(0, packetsCompiled - packetsFailed);
+    let rerunOutcome = null;
+    if (lastRerun) {
+        const action = asString(lastRerun["action"]);
+        if (action === "pass")
+            rerunOutcome = "pass";
+        else if (action === "findings")
+            rerunOutcome = "findings";
+        else if (action === "failure" || action === "error")
+            rerunOutcome = "failed";
+        else if (action === "skipped")
+            rerunOutcome = "skipped";
+    }
+    return {
+        status,
+        rounds_completed: roundsCompleted,
+        max_rounds: maxRounds,
+        packets_compiled: packetsCompiled,
+        packets_completed: packetsCompleted,
+        packets_failed: packetsFailed,
+        rerun_outcome: rerunOutcome,
+        provider_attempts: computeProviderAttemptSummary(qcResults, telemetryEvents),
+    };
+}
 /**
  * Computes a QcScoreSummary from the QC results loaded for this run.
  * Returns null when no QC results are present.
@@ -263,7 +419,7 @@ function computeQcPenalty(weightedOpenScore) {
  * a critical/high-confidence finding hurts SOL scoring more than a low-severity
  * or uncertain finding.
  */
-function computeQcSummary(qcResults) {
+function computeQcSummary(qcResults, clusterState = null, telemetryEvents = [], currentState = null) {
     if (qcResults.length === 0)
         return null;
     let total = 0;
@@ -362,6 +518,11 @@ function computeQcSummary(qcResults) {
         .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));
+    const repairLoop = computeQcRepairLoopSummary(qcResults, clusterState, telemetryEvents, currentState);
+    const noisyProviders = Array.from(providerBreakdown.entries())
+        .filter(([, counts]) => counts.total >= 2 && counts.unvalidated / counts.total >= 0.5)
+        .map(([provider]) => provider)
+        .sort();
     return {
         total_findings: total,
         blocking_findings: blocking,
@@ -379,6 +540,11 @@ function computeQcSummary(qcResults) {
         category_breakdown: Object.fromEntries(categoryBreakdown),
         recurring_child_signals: recurringChildSignals,
         recurring_provider_signals: recurringProviderSignals,
+        repair_loop: repairLoop,
+        noisy_providers: noisyProviders,
+        has_repair_failures: repairLoop.packets_failed > 0 || repairLoop.status === "medic-referral",
+        unresolved_high_severity: openBySeverity.critical + openBySeverity.high,
+        max_round_exhausted: repairLoop.status === "max-rounds",
     };
 }
 function asRecord(value) {
@@ -386,6 +552,12 @@ function asRecord(value) {
         ? value
         : undefined;
 }
+function asString(value) {
+    return typeof value === "string" ? value : null;
+}
+function asNumber(value) {
+    return typeof value === "number" ? value : null;
+}
 function asStringArray(value) {
     if (!Array.isArray(value))
         return [];
@@ -485,7 +657,7 @@ function scoreRun(repoRoot, runId) {
     const score = computeScore(gateResults);
     const diagnosisHints = buildDiagnosisHints(failedGates);
     const routerOutcomes = summarizeRouterOutcomes(artifacts);
-    const qcSummary = computeQcSummary(artifacts.qcResults);
+    const qcSummary = computeQcSummary(artifacts.qcResults, artifacts.clusterState, artifacts.telemetryEvents, artifacts.currentState);
     const clusterId = artifacts.currentState &&
         typeof artifacts.currentState === "object" &&
         !Array.isArray(artifacts.currentState)

package/dist/autoresearch/sol-evidence-loader.js

@@ -293,9 +293,11 @@ function buildRouterEvidence(artifacts) {
 // QC evidence
 // ──────────────────────────────────────────────
 function buildQcEvidence(artifacts) {
+    const disabledOutcome = artifacts.clusterState?.qc_repair_outcome;
+    const isDisabled = disabledOutcome === "qc-disabled";
     if (artifacts.qcResults.length === 0) {
-        return {
-            availability: "future",
+        const base = {
+            availability: isDisabled ? "unavailable" : "future",
             qc_run_count: 0,
             total_findings: 0,
             blocking_findings: 0,
@@ -307,9 +309,32 @@ function buildQcEvidence(artifacts) {
             qc_penalty: 0,
             blocks_delivery: false,
             open_by_severity: { critical: 0, high: 0, medium: 0, low: 0, info: 0 },
+            provider_breakdown: {},
+            repair_loop: {
+                status: isDisabled ? "not-configured" : "not-run",
+                rounds_completed: 0,
+                max_rounds: 0,
+                packets_compiled: 0,
+                packets_completed: 0,
+                packets_failed: 0,
+                rerun_outcome: null,
+                provider_attempts: {
+                    total: 0,
+                    success: 0,
+                    failure: 0,
+                    fallback: 0,
+                    skipped: 0,
+                    all_providers_failed: false,
+                },
+            },
+            noisy_providers: [],
+            has_repair_failures: false,
+            unresolved_high_severity: 0,
+            max_round_exhausted: false,
         };
+        return base;
     }
-    const summary = (0, score_js_1.computeQcSummary)(artifacts.qcResults);
+    const summary = (0, score_js_1.computeQcSummary)(artifacts.qcResults, artifacts.clusterState, artifacts.telemetryEvents, artifacts.currentState);
     if (!summary) {
         // computeQcSummary only returns null when qcResults is empty; handled above.
         // ponytail: defensive branch to satisfy type narrowing
@@ -326,6 +351,12 @@ function buildQcEvidence(artifacts) {
             qc_penalty: 0,
             blocks_delivery: false,
             open_by_severity: { critical: 0, high: 0, medium: 0, low: 0, info: 0 },
+            provider_breakdown: {},
+            repair_loop: null,
+            noisy_providers: [],
+            has_repair_failures: false,
+            unresolved_high_severity: 0,
+            max_round_exhausted: false,
         };
     }
     return {
@@ -341,6 +372,12 @@ function buildQcEvidence(artifacts) {
         qc_penalty: summary.qc_penalty,
         blocks_delivery: summary.blocks_delivery,
         open_by_severity: { ...summary.open_by_severity },
+        provider_breakdown: { ...summary.provider_breakdown },
+        repair_loop: summary.repair_loop,
+        noisy_providers: [...summary.noisy_providers],
+        has_repair_failures: summary.has_repair_failures,
+        unresolved_high_severity: summary.unresolved_high_severity,
+        max_round_exhausted: summary.max_round_exhausted,
     };
 }
 // ──────────────────────────────────────────────

package/dist/autoresearch/sol-recommendations.js

@@ -19,6 +19,8 @@ exports.generateRecommendations = generateRecommendations;
 exports.recommendationToProposal = recommendationToProposal;
 exports.recommendationsToProposals = recommendationsToProposals;
 exports.formatRecommendationsCli = formatRecommendationsCli;
+exports.generateQcRecommendations = generateQcRecommendations;
+exports.formatQcRecommendations = formatQcRecommendations;
 const sol_report_js_1 = require("./sol-report.js");
 // ──────────────────────────────────────────────
 // Constants and helpers
@@ -298,3 +300,83 @@ function formatRecommendationsCli(report) {
     }
     return lines.join("\n");
 }
+function makeQcRecommendation(id, category, actionType, affected, proposedAction, rationale, confidence, evidenceRunId) {
+    return {
+        id,
+        category,
+        action_type: actionType,
+        affected,
+        proposed_action: proposedAction,
+        confidence: clamp01(confidence),
+        evidence: {
+            group_key: `run_id=${evidenceRunId}`,
+            grouped_by: ["run_id"],
+            count: 1,
+            mean_composite: null,
+            min_composite: null,
+            max_composite: null,
+            mean_foreman_composite: null,
+            mean_worker_composite: null,
+            run_ids: [evidenceRunId],
+        },
+        rationale,
+    };
+}
+/**
+ * Generate QC repair-loop follow-up recommendations from a single run's
+ * SOL evidence. These are advisory signals for noisy providers, repeated
+ * repair failures, unresolved high-severity findings, and max-round exhaustion.
+ */
+function generateQcRecommendations(evidence) {
+    const recommendations = [];
+    const qc = evidence.qc;
+    const runId = evidence.run_id;
+    if (qc.availability !== "available") {
+        return {
+            generated_at: new Date().toISOString(),
+            evidence_run_id: runId,
+            recommendations,
+        };
+    }
+    for (const provider of qc.noisy_providers) {
+        const counts = qc.provider_breakdown[provider] ?? { total: 0, blocking: 0, unvalidated: 0 };
+        const confidence = counts.total > 0 ? counts.unvalidated / counts.total : 0;
+        recommendations.push(makeQcRecommendation(`qc-noisy-provider:${provider}`, "provider_policy", "analyze", { provider }, `Review QC provider '${provider}' for noisy/unvalidated findings; consider raising attribution confidence thresholds or disabling the provider for high-risk routes.`, `${counts.unvalidated}/${counts.total} findings from '${provider}' are unvalidated noise.`, confidence, runId));
+    }
+    if (qc.has_repair_failures) {
+        const failed = qc.repair_loop?.packets_failed ?? 0;
+        recommendations.push(makeQcRecommendation(`qc-repair-failure:${runId}`, "qc_follow_up", "implement", {}, "Repeated repair worker failures detected — inspect repair packet scope, validation commands, and Medic referral path.", `${failed} repair packet(s) failed; consider tightening acceptance criteria or escalating to Medic.`, 0.9, runId));
+    }
+    if (qc.unresolved_high_severity > 0) {
+        recommendations.push(makeQcRecommendation(`qc-unresolved-high-severity:${runId}`, "qc_follow_up", "analyze", {}, `${qc.unresolved_high_severity} unresolved critical/high QC findings remain — triage before delivery.`, `${qc.unresolved_high_severity} critical/high findings are still open after repair loop.`, Math.min(1, qc.unresolved_high_severity / 5), runId));
+    }
+    if (qc.max_round_exhausted) {
+        recommendations.push(makeQcRecommendation(`qc-max-rounds:${runId}`, "qc_follow_up", "analyze", {}, "QC repair loop exhausted max rounds — review provider noise, repair packet scope, and escalation policy.", `Repair loop reached round ${qc.repair_loop?.rounds_completed ?? 0}/${qc.repair_loop?.max_rounds ?? 0} without passing.`, 0.85, runId));
+    }
+    return {
+        generated_at: new Date().toISOString(),
+        evidence_run_id: runId,
+        recommendations,
+    };
+}
+function formatQcRecommendations(report) {
+    const lines = [];
+    lines.push("SOL QC Follow-Up Recommendations");
+    lines.push(`Generated: ${report.generated_at}`);
+    lines.push(`Run: ${report.evidence_run_id}`);
+    lines.push("");
+    if (report.recommendations.length === 0) {
+        lines.push("No QC follow-up signals detected.");
+        return lines.join("\n") + "\n";
+    }
+    for (const r of report.recommendations) {
+        lines.push(`[${r.action_type}] ${r.id}`);
+        lines.push(`  Category:    ${r.category}`);
+        lines.push(`  Affected:    ${fmtAffected(r.affected)}`);
+        lines.push(`  Confidence:  ${(r.confidence * 100).toFixed(1)}%`);
+        lines.push(`  Action:      ${r.proposed_action}`);
+        lines.push(`  Rationale:   ${r.rationale}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/autoresearch/sol-report.js

@@ -11,6 +11,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateReport = generateReport;
 exports.formatReportCli = formatReportCli;
+exports.formatQcEvidence = formatQcEvidence;
 // ──────────────────────────────────────────────
 // Helpers
 // ──────────────────────────────────────────────
@@ -151,3 +152,46 @@ function formatReportCli(report) {
 function padRight(s, n) {
     return s.length >= n ? s : s + " ".repeat(n - s.length);
 }
+/**
+ * Render a human-readable summary of QC evidence and repair-loop outcomes.
+ */
+function formatQcEvidence(qc) {
+    const lines = [];
+    lines.push("QC Evidence Summary");
+    lines.push(`  availability: ${qc.availability}`);
+    lines.push(`  qc_run_count: ${qc.qc_run_count}`);
+    lines.push(`  total_findings: ${qc.total_findings}`);
+    lines.push(`  repaired: ${qc.repaired_findings}, open: ${qc.total_findings - qc.repaired_findings - qc.autofixed_findings - qc.waived_findings}`);
+    lines.push(`  unresolved high/critical: ${qc.unresolved_high_severity}`);
+    lines.push(`  blocks_delivery: ${qc.blocks_delivery}`);
+    lines.push("");
+    const providers = Object.entries(qc.provider_breakdown);
+    if (providers.length > 0) {
+        lines.push("Provider breakdown:");
+        for (const [provider, counts] of providers) {
+            lines.push(`  ${provider}: total=${counts.total}, blocking=${counts.blocking}, unvalidated=${counts.unvalidated}`);
+        }
+        lines.push("");
+    }
+    if (qc.repair_loop) {
+        const loop = qc.repair_loop;
+        lines.push("Repair loop:");
+        lines.push(`  status: ${loop.status}`);
+        lines.push(`  rounds: ${loop.rounds_completed}/${loop.max_rounds}`);
+        lines.push(`  packets: ${loop.packets_compiled} compiled, ${loop.packets_completed} completed, ${loop.packets_failed} failed`);
+        lines.push(`  rerun_outcome: ${loop.rerun_outcome ?? "n/a"}`);
+        lines.push(`  provider_attempts: total=${loop.provider_attempts.total}, success=${loop.provider_attempts.success}, failure=${loop.provider_attempts.failure}, fallback=${loop.provider_attempts.fallback}, skipped=${loop.provider_attempts.skipped}`);
+        lines.push(`  all_providers_failed: ${loop.provider_attempts.all_providers_failed}`);
+        lines.push("");
+    }
+    if (qc.noisy_providers.length > 0) {
+        lines.push(`Noisy providers: ${qc.noisy_providers.join(", ")}`);
+    }
+    if (qc.has_repair_failures) {
+        lines.push("Repeated repair failures detected.");
+    }
+    if (qc.max_round_exhausted) {
+        lines.push("Max repair rounds exhausted.");
+    }
+    return lines.join("\n").trim() + "\n";
+}

package/dist/autoresearch/sol-scorer.js

@@ -207,6 +207,48 @@ function scoreForemanCompletion(ev) {
         detail: `succeeded=${succeeded}/${total}`,
     });
 }
+/**
+ * qc_repair_loop: Observe QC repair loop outcomes.
+ *
+ * Scores repair loop terminal states without treating provider findings as
+ * ground truth. Best outcome = loop passed or no repairable findings.
+ * Worst = all providers failed, operator review required, or Medic referral.
+ * Skipped when QC is not configured or no repair loop ran.
+ */
+function scoreForemanQcRepairLoop(ev) {
+    if (ev.qc.availability === "future" || ev.qc.availability === "unavailable") {
+        return skipped("qc_repair_loop", `QC evidence availability=${ev.qc.availability}`);
+    }
+    const loop = ev.qc.repair_loop;
+    if (!loop) {
+        return skipped("qc_repair_loop", "no QC repair loop data available");
+    }
+    const { status, rounds_completed, max_rounds, packets_compiled, packets_failed, rerun_outcome } = loop;
+    switch (status) {
+        case "passed":
+        case "repaired":
+        case "no-repairable":
+            return dim("qc_repair_loop", 1.0, "high", {
+                detail: `status=${status}, rounds=${rounds_completed}/${max_rounds}, packets=${packets_compiled}, rerun=${rerun_outcome ?? "n/a"}`,
+            });
+        case "max-rounds":
+            return dim("qc_repair_loop", 0.5, "high", {
+                detail: `status=${status}, rounds=${rounds_completed}/${max_rounds}, packets=${packets_compiled}`,
+            });
+        case "all-providers-failed":
+        case "operator-review":
+        case "medic-referral":
+            return dim("qc_repair_loop", 0.0, "high", {
+                detail: `status=${status}, failed_packets=${packets_failed}, rerun=${rerun_outcome ?? "n/a"}`,
+            });
+        case "not-run":
+        case "not-configured":
+        case "in-progress":
+        case "unknown":
+        default:
+            return skipped("qc_repair_loop", `QC repair loop status=${status}`);
+    }
+}
 /**
  * recovery: State repair detection.
  * Score = 1.0 when no medic/repair artifacts detected; 0.0 when repair required.
@@ -388,10 +430,11 @@ function computeForemanScore(ev) {
     const scopeDim = scoreForemanScope(ev);
     const completionDim = scoreForemanCompletion(ev);
     const recoveryDim = scoreForemanRecovery(ev);
+    const qcRepairLoopDim = scoreForemanQcRepairLoop(ev);
     const dims = [
         tokenDim, durationDim, interventionDim, preAnalysisDim,
         dependencyDim, dispatchDim, evidenceValidationDim, scopeDim,
-        completionDim, recoveryDim,
+        completionDim, recoveryDim, qcRepairLoopDim,
     ];
     const { score: composite_score, confidence: composite_confidence } = composite(dims);
     return {
@@ -407,6 +450,7 @@ function computeForemanScore(ev) {
         scope: scopeDim,
         completion: completionDim,
         recovery: recoveryDim,
+        qc_repair_loop: qcRepairLoopDim,
     };
 }
 /**

package/dist/config/defaults.js

@@ -119,5 +119,6 @@ exports.DEFAULT_CONFIG = {
             maxRuns: 10,
         },
         routes: {},
+        maxRepairRounds: 2,
     },
 };