@lsctech/polaris 0.5.7 → 0.5.9

package/dist/qc/providers/coderabbit.js

@@ -16,6 +16,79 @@ function pickString(...candidates) {
     }
     return undefined;
 }
+const FINDING_LOCATION_KEYS = ["file", "filePath", "path"];
+const FINDING_REVIEW_KEYS = [
+    "severity",
+    "message",
+    "title",
+    "summary",
+    "description",
+    "body",
+    "rule",
+    "category",
+    "suggestion",
+    "suggestedAction",
+    "fix",
+    "providerFindingId",
+    "id",
+    "findingId",
+];
+const PROGRESS_SHAPE_KEYS = new Set(["event", "progress", "heartbeat", "complete", "review_context"]);
+const PROGRESS_TYPE_VALUES = new Set([
+    "progress",
+    "status",
+    "heartbeat",
+    "complete",
+    "review_context",
+    "reviewcontext",
+]);
+const PROGRESS_STATUS_VALUES = new Set([
+    "in_progress",
+    "running",
+    "pending",
+    "complete",
+    "completed",
+    "done",
+    "heartbeat",
+    "ok",
+    "success",
+]);
+function hasFindingLocation(record) {
+    return FINDING_LOCATION_KEYS.some((key) => record[key] !== undefined);
+}
+function hasFindingReviewContent(record) {
+    return FINDING_REVIEW_KEYS.some((key) => record[key] !== undefined);
+}
+function isProgressRecord(record) {
+    // Check progress/status indicators FIRST before the generic finding-content guard
+    const keys = Object.keys(record);
+    if (keys.length === 0)
+        return false;
+    if (keys.some((key) => PROGRESS_SHAPE_KEYS.has(key)))
+        return true;
+    if (typeof record.type === "string" && PROGRESS_TYPE_VALUES.has(record.type.toLowerCase()))
+        return true;
+    if (typeof record.status === "string" && PROGRESS_STATUS_VALUES.has(record.status.toLowerCase()))
+        return true;
+    // Status-only records with category="status" are progress records even if they have message/title fields
+    if (typeof record.category === "string" && record.category.toLowerCase() === "status")
+        return true;
+    // Only reject as progress if it has both location AND review content (true finding shape)
+    if (hasFindingLocation(record) && hasFindingReviewContent(record)) {
+        return false;
+    }
+    return false;
+}
+function isActionableFinding(record) {
+    if (isProgressRecord(record))
+        return false;
+    return hasFindingLocation(record) || hasFindingReviewContent(record);
+}
+function makeUnusableOutputError(message) {
+    const err = new Error(message);
+    err.qcFailureReason = "unusable-output";
+    return err;
+}
 function buildRange(raw) {
     const startLine = coerceNumber(raw.startLine ?? raw.line) ?? 1;
     const endLine = coerceNumber(raw.endLine);
@@ -37,18 +110,16 @@ function parseFindingsFromPayload(payload) {
     }
     const record = payload;
     if (Array.isArray(record.findings)) {
-        return record.findings;
+        return record.findings.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
     }
     if (Array.isArray(record.issues)) {
-        return record.issues;
+        return record.issues.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
     }
     if (Array.isArray(record.results)) {
-        return record.results;
+        return record.results.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
     }
     // Single finding wrapped in an object
-    if (record.severity !== undefined ||
-        record.message !== undefined ||
-        record.title !== undefined) {
+    if (isActionableFinding(record)) {
         return [record];
     }
     return [];
@@ -77,10 +148,21 @@ function parseReport(output, format, parser) {
         try {
             const parsed = JSON.parse(text);
             if (Array.isArray(parsed)) {
-                return { findings: parsed };
+                const findings = parsed.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
+                if (findings.length === 0 && parsed.length > 0) {
+                    const progressCount = parsed.filter((item) => typeof item === "object" && item !== null && isProgressRecord(item)).length;
+                    if (progressCount > 0) {
+                        throw makeUnusableOutputError(`CodeRabbit output contained only progress/status/heartbeat records (${progressCount} items)`);
+                    }
+                }
+                return { findings };
+            }
+            const findings = parseFindingsFromPayload(parsed);
+            if (findings.length === 0 && isProgressRecord(parsed)) {
+                throw makeUnusableOutputError("CodeRabbit output was a progress/status/heartbeat record");
             }
             return {
-                findings: parseFindingsFromPayload(parsed),
+                findings,
                 ...(typeof parsed?.prUrl === "string"
                     ? { prUrl: parsed.prUrl }
                     : {}),
@@ -97,10 +179,23 @@ function parseReport(output, format, parser) {
     // JSONL or generic line scanning: one finding per line
     const lines = text.split("\n").filter((line) => line.trim().length > 0);
     const lineFindings = [];
+    let progressLineCount = 0;
+    let parsedLineCount = 0;
     for (const line of lines) {
         try {
             const parsed = JSON.parse(line);
-            lineFindings.push(parsed);
+            parsedLineCount++;
+            if (!parsed || typeof parsed !== "object") {
+                continue;
+            }
+            const record = parsed;
+            if (isProgressRecord(record)) {
+                progressLineCount++;
+                continue;
+            }
+            if (isActionableFinding(record)) {
+                lineFindings.push(parsed);
+            }
         }
         catch {
             // Ignore unparseable lines.
@@ -109,6 +204,12 @@ function parseReport(output, format, parser) {
     if (lineFindings.length > 0) {
         return { findings: lineFindings };
     }
+    if (progressLineCount > 0) {
+        throw makeUnusableOutputError(`CodeRabbit output contained only progress/status/heartbeat records (${progressLineCount} lines)`);
+    }
+    if (parsedLineCount > 0) {
+        throw new Error("CodeRabbit output contained no actionable findings");
+    }
     throw new Error("CodeRabbit output could not be parsed as JSON, JSONL, or metrics payload");
 }
 function normalizeFinding(raw, index) {
@@ -217,20 +318,22 @@ class CodeRabbitQcProvider {
             if (execution.configPath) {
                 args.push("--config", execution.configPath);
             }
+            const baseRef = scope.baseRef ?? scope.branch ?? "main";
             if (scope.prUrl) {
                 args.push("--pr-url", scope.prUrl);
             }
             else {
-                args.push("--branch", scope.branch ?? "HEAD");
+                args.push("--base", baseRef);
             }
             return { command: execution.command, args };
         }
         if (scope.prUrl) {
             return { command: "coderabbit", args: ["review", "--agent", "--pr-url", scope.prUrl] };
         }
+        const baseRef = scope.baseRef ?? scope.branch ?? "main";
         return {
             command: "coderabbit",
-            args: ["review", "--agent", "--branch", scope.branch ?? "HEAD"],
+            args: ["review", "--agent", "--base", baseRef],
         };
     }
     parse(output) {

package/dist/qc/repair-loop.js

@@ -33,6 +33,43 @@ function appendTelemetry(telemetryFile, event) {
     (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(telemetryFile), { recursive: true });
     (0, node_fs_1.appendFileSync)(telemetryFile, JSON.stringify(event) + "\n", "utf-8");
 }
+async function persistQcRepairOutcome(clusterId, repoRoot, outcome) {
+    try {
+        const clusterState = (0, store_js_1.readClusterStateSync)(clusterId, repoRoot);
+        if (!clusterState)
+            return;
+        await (0, store_js_1.writeClusterState)(clusterId, {
+            ...clusterState,
+            state_generation: clusterState.state_generation + 1,
+            qc_repair_outcome: outcome,
+        }, repoRoot);
+    }
+    catch {
+        // Best-effort: the loop outcome is already returned to the caller and
+        // recorded in the loop checkpoint. Do not block finalization on a
+        // cluster-state write race.
+    }
+}
+async function persistQcRepairManifest(clusterId, repoRoot, round, manifestPath) {
+    try {
+        const clusterState = (0, store_js_1.readClusterStateSync)(clusterId, repoRoot);
+        if (!clusterState)
+            return;
+        const manifests = { ...(clusterState.qc_repair_manifests ?? {}), [round]: manifestPath };
+        if (clusterState.qc_repair_manifests &&
+            clusterState.qc_repair_manifests[round] === manifestPath) {
+            return;
+        }
+        await (0, store_js_1.writeClusterState)(clusterId, {
+            ...clusterState,
+            state_generation: clusterState.state_generation + 1,
+            qc_repair_manifests: manifests,
+        }, repoRoot);
+    }
+    catch {
+        // Best-effort durability for repair-round manifest pointer.
+    }
+}
 /** Returns true when any finding in the results routes to repair-worker. */
 function hasRepairableFindings(results) {
     return results.some((r) => r.findings.some((f) => (f.routingDecision === "repair-worker" || f.routingDecision === "original-worker") &&
@@ -109,6 +146,7 @@ async function runQcRepairLoop(options) {
         });
         state.terminal_outcome = "qc-disabled";
         state.updated_at = new Date().toISOString();
+        await persistQcRepairOutcome(clusterId, repoRoot, "qc-disabled");
         return {
             outcome: "qc-disabled",
             rounds_completed: 0,
@@ -147,6 +185,7 @@ async function runQcRepairLoop(options) {
                 round,
                 timestamp: new Date().toISOString(),
             });
+            await persistQcRepairOutcome(clusterId, repoRoot, "all-providers-failed");
             return {
                 outcome: "all-providers-failed",
                 rounds_completed: roundsCompleted,
@@ -165,6 +204,7 @@ async function runQcRepairLoop(options) {
                 round,
                 timestamp: new Date().toISOString(),
             });
+            await persistQcRepairOutcome(clusterId, repoRoot, "operator-review");
             return {
                 outcome: "operator-review",
                 rounds_completed: roundsCompleted,
@@ -189,19 +229,7 @@ async function runQcRepairLoop(options) {
             });
             manifest = compiled.manifest;
             // Update cluster state with manifest path.
-            try {
-                const clusterState = (0, store_js_1.readClusterStateSync)(clusterId, repoRoot);
-                if (clusterState) {
-                    const repairManifests = {
-                        ...(clusterState.qc_repair_manifests ?? {}),
-                        [round]: compiled.manifestPath,
-                    };
-                    await (0, store_js_1.writeClusterState)(clusterId, { ...clusterState, state_generation: clusterState.state_generation + 1, qc_repair_manifests: repairManifests }, repoRoot);
-                }
-            }
-            catch {
-                // Non-fatal: cluster state update is best-effort.
-            }
+            await persistQcRepairManifest(clusterId, repoRoot, round, compiled.manifestPath);
             loopState = {
                 ...loopState,
                 current_round: round,
@@ -221,13 +249,16 @@ async function runQcRepairLoop(options) {
             });
         }
         else {
+            const existingManifestPath = loopState.manifest_path ??
+                (0, node_path_1.join)(repoRoot, ".polaris", "clusters", clusterId, "qc", "repair-rounds", String(round), "repair-packets.json");
             loopState = {
                 ...loopState,
                 current_round: round,
-                manifest_path: loopState.manifest_path ?? (0, node_path_1.join)(repoRoot, ".polaris", "clusters", clusterId, "qc", "repair-rounds", String(round), "repair-packets.json"),
+                manifest_path: existingManifestPath,
                 updated_at: new Date().toISOString(),
             };
             onStateUpdate?.(loopState);
+            await persistQcRepairManifest(clusterId, repoRoot, round, existingManifestPath);
         }
         // ── Check for repairable packets ────────────────────────────────────────
         const repairablePackets = manifest.packets.filter((p) => p.routingTarget === "repair-worker" &&
@@ -243,6 +274,7 @@ async function runQcRepairLoop(options) {
                 round,
                 timestamp: new Date().toISOString(),
             });
+            await persistQcRepairOutcome(clusterId, repoRoot, "no-repairable");
             return {
                 outcome: "no-repairable",
                 rounds_completed: roundsCompleted,
@@ -309,6 +341,7 @@ async function runQcRepairLoop(options) {
                 failed_count: failedWorkers.length,
                 timestamp: new Date().toISOString(),
             });
+            await persistQcRepairOutcome(clusterId, repoRoot, "medic-referral");
             return {
                 outcome: "medic-referral",
                 rounds_completed: roundsCompleted + 1,
@@ -394,6 +427,7 @@ async function runQcRepairLoop(options) {
                 round,
                 timestamp: new Date().toISOString(),
             });
+            await persistQcRepairOutcome(clusterId, repoRoot, "pass");
             return {
                 outcome: "pass",
                 rounds_completed: roundsCompleted,
@@ -413,6 +447,7 @@ async function runQcRepairLoop(options) {
         rounds_completed: roundsCompleted,
         timestamp: new Date().toISOString(),
     });
+    await persistQcRepairOutcome(clusterId, repoRoot, "max-rounds");
     return {
         outcome: "max-rounds",
         rounds_completed: roundsCompleted,

package/dist/qc/runner.js

@@ -298,8 +298,16 @@ async function runSingleProvider(provider, scope, options, fallbackSource) {
                 resolve({ result, success: true });
             }
             catch (parseError) {
-                const result = buildFailedResult(provider, scope, startedAt, "parse-failed", output, { parserResult: "failed" });
-                emitProviderFailed(options.telemetryFile, scope.runId, scope.clusterId, provider.name, "parse-failed", output.exitCode);
+                const reason = typeof parseError === "object" &&
+                    parseError !== null &&
+                    "qcFailureReason" in parseError &&
+                    typeof parseError.qcFailureReason === "string"
+                    ? parseError.qcFailureReason
+                    : "parse-failed";
+                const result = buildFailedResult(provider, scope, startedAt, reason, output, {
+                    parserResult: "failed",
+                });
+                emitProviderFailed(options.telemetryFile, scope.runId, scope.clusterId, provider.name, reason, output.exitCode);
                 resolve({ result, success: false });
             }
         });

package/dist/qc/schemas.js

@@ -42,6 +42,7 @@ exports.qcFailureReasonSchema = zod_1.z.enum([
     "nonzero-exit",
     "parse-failed",
     "empty-output",
+    "unusable-output",
     "unsupported-mode",
     "unavailable-provider",
 ]);

package/dist/run-health/foreman-symptoms.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Foreman-side runtime symptom emission.
+ *
+ * The Foreman appends symptoms ONLY for Polaris-runtime intervention events
+ * (state repair, cluster repair, missing packet/result repair, dispatch
+ * boundary repair, QC/finalize runtime failure, local/global binary mismatch,
+ * and manual intervention).
+ *
+ * Symptoms are NOT emitted for non-Polaris target repositories unless
+ * `run_health.foreman_symptoms.enabled` is explicitly set to true in
+ * polaris.config.json.
+ *
+ * QC providers remain unchanged artifact producers — they never write here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isForemanSymptomEnabled = isForemanSymptomEnabled;
+exports.appendForemanSymptom = appendForemanSymptom;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("./index.js");
+// ── Policy ────────────────────────────────────────────────────────────────────
+/**
+ * Returns true when Foreman-side symptom emission is enabled.
+ *
+ * Emission is enabled when `run_health.foreman_symptoms.enabled === true` in
+ * the project's polaris.config.json. Foreman symptoms are disabled by default
+ * so that non-Polaris target repositories are not automatically marked sick.
+ */
+function isForemanSymptomEnabled(config) {
+    return config?.run_health?.foreman_symptoms?.enabled === true;
+}
+/**
+ * Append a Foreman-side runtime symptom to the run-health report.
+ *
+ * Creates the report when one does not yet exist; appends to it when one does.
+ * When `config` is provided, checks `isForemanSymptomEnabled(config)` and
+ * no-ops when disabled (so the caller does not need to guard).
+ * Never throws — symptom emission is advisory and must not block the run.
+ */
+function appendForemanSymptom(params) {
+    const { runId, clusterId, code, message, evidenceRefs, repoRoot, config } = params;
+    // Policy gate: skip when config is provided but policy is not enabled.
+    if (config !== undefined && !isForemanSymptomEnabled(config)) {
+        return;
+    }
+    const sourceActor = {
+        role: "foreman",
+    };
+    const symptom = {
+        id: `foreman:${code}:${(0, node_crypto_1.randomUUID)()}`,
+        severity: foremanCodeSeverity(code),
+        code,
+        message,
+        source_actor: sourceActor,
+        evidence_refs: evidenceRefs ?? [],
+        occurred_at: new Date().toISOString(),
+    };
+    try {
+        const existing = (0, index_js_1.readRunHealthReport)(runId, repoRoot);
+        if (!existing) {
+            (0, index_js_1.createRunHealthReport)({
+                runId,
+                clusterId,
+                firstSymptom: symptom,
+                sourceActor,
+                repoRoot,
+            });
+        }
+        else {
+            (0, index_js_1.appendSymptom)(runId, symptom, repoRoot);
+        }
+    }
+    catch {
+        // Symptom emission must never block the run — swallow errors silently.
+        // ponytail: surface to telemetry in a future pass
+    }
+}
+/**
+ * Maps a Foreman symptom code to its default severity.
+ */
+function foremanCodeSeverity(code) {
+    switch (code) {
+        case "foreman-dispatch-boundary-repair":
+            return "critical";
+        case "foreman-state-repair":
+        case "foreman-cluster-repair":
+        case "foreman-packet-repair":
+        case "foreman-qc-runtime-failure":
+        case "foreman-medic-runtime-failure":
+        case "foreman-binary-mismatch":
+        case "foreman-wrong-run-telemetry":
+            return "high";
+        case "foreman-finalize-recovery":
+            return "medium";
+        case "foreman-manual-intervention":
+            return "low";
+        default:
+            return "medium";
+    }
+}