@lsctech/polaris 0.5.7 → 0.5.9

package/dist/cli/autoresearch.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAutoresearchCommand = void 0;
 exports.createSolCommand = createSolCommand;
 const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
 const commander_1 = require("commander");
 const dev_gate_js_1 = require("../autoresearch/dev-gate.js");
 const score_js_1 = require("../autoresearch/score.js");
@@ -12,6 +13,9 @@ const sol_evidence_loader_js_1 = require("../autoresearch/sol-evidence-loader.js
 const sol_scorer_js_1 = require("../autoresearch/sol-scorer.js");
 const sol_history_js_1 = require("../autoresearch/sol-history.js");
 const sol_report_js_1 = require("../autoresearch/sol-report.js");
+const sol_scorecard_calculator_js_1 = require("../autoresearch/sol-scorecard-calculator.js");
+const sol_evaluation_writer_js_1 = require("../autoresearch/sol-evaluation-writer.js");
+const sol_report_renderer_js_1 = require("../autoresearch/sol-report-renderer.js");
 const sol_recommendations_js_1 = require("../autoresearch/sol-recommendations.js");
 function createSolCommand(options) {
     const repoRoot = options.repoRoot;
@@ -74,6 +78,79 @@ function createSolCommand(options) {
             process.exit(1);
         }
     });
+    sol
+        .command("report <run-id>")
+        .description("Generate SOL evaluation artifacts and a human-readable SmartDocs report for a run")
+        .option("-r, --repo-root <path>", "Repository root", repoRoot)
+        .option("--format <mode>", "Output format: markdown or json", "markdown")
+        .option("--json", "Output raw JSON (same as --format json)")
+        .option("--no-write", "Skip writing artifact files")
+        .action((runId, cmdOptions) => {
+        const root = (0, node_path_1.resolve)(cmdOptions.repoRoot ?? repoRoot);
+        if (cmdOptions.format !== "markdown" && cmdOptions.format !== "json") {
+            process.stderr.write(`sol report error: invalid --format "${cmdOptions.format}" (expected "markdown" or "json")\n`);
+            process.exit(1);
+        }
+        try {
+            (0, dev_gate_js_1.assertPolarisDevContext)(root);
+        }
+        catch (err) {
+            process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+        let artifacts;
+        let evidence;
+        try {
+            artifacts = (0, score_js_1.loadRunArtifacts)(root, runId);
+            evidence = (0, sol_evidence_loader_js_1.aggregateSolEvidence)(artifacts);
+        }
+        catch (err) {
+            process.stderr.write(`sol report error: cannot load run artifacts: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+        try {
+            const report = (0, sol_scorer_js_1.computeSolScoreReport)(evidence);
+            const scorecards = (0, sol_scorecard_calculator_js_1.computeAllScorecards)(evidence);
+            const qcRecommendations = (0, sol_recommendations_js_1.generateQcRecommendations)(evidence);
+            let evaluationPath;
+            let scorecardPaths;
+            let markdownPath;
+            const evaluationRecord = (0, sol_evaluation_writer_js_1.buildEvaluationRecord)(report);
+            const rendered = (0, sol_report_renderer_js_1.renderSolMarkdown)(evaluationRecord, scorecards, qcRecommendations);
+            if (cmdOptions.write) {
+                // Persist the same evaluationRecord object that was rendered, rather than rebuilding internally
+                const evaluationDir = (0, sol_evaluation_writer_js_1.getSolEvaluationsDir)(root);
+                if (!(0, node_fs_1.existsSync)(evaluationDir))
+                    (0, node_fs_1.mkdirSync)(evaluationDir, { recursive: true });
+                evaluationPath = (0, sol_evaluation_writer_js_1.getEvaluationRecordPath)(root, report.run_id);
+                (0, node_fs_1.writeFileSync)(evaluationPath, JSON.stringify(evaluationRecord, null, 2) + "\n", "utf-8");
+                scorecardPaths = (0, sol_evaluation_writer_js_1.writeScorecardSet)(root, scorecards);
+                markdownPath = (0, sol_evaluation_writer_js_1.writeSolMarkdownReport)(root, runId, rendered.markdown);
+            }
+            const outputFormat = cmdOptions.json || cmdOptions.format === "json" ? "json" : "markdown";
+            if (outputFormat === "json") {
+                const output = JSON.stringify({
+                    run_id: runId,
+                    evaluation: evaluationRecord,
+                    scorecards,
+                    qc_recommendations: qcRecommendations,
+                    artifacts: {
+                        evaluation: evaluationPath,
+                        scorecards: scorecardPaths,
+                        markdown: markdownPath,
+                    },
+                }, null, 2);
+                process.stdout.write(`${output}\n`);
+            }
+            else {
+                process.stdout.write(rendered.markdown);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`sol report error: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    });
     sol
         .command("propose <diagnosis-file>")
         .description("File Linear improvement proposals from a diagnosis report (dev-gated — never auto-applied)")

package/dist/cli/medic.js

@@ -5,6 +5,10 @@ const commander_1 = require("commander");
 const node_path_1 = require("node:path");
 const node_fs_1 = require("node:fs");
 const chart_id_js_1 = require("../medic/chart-id.js");
+const loader_js_1 = require("../config/loader.js");
+const terminal_cli_js_1 = require("../loop/adapters/terminal-cli.js");
+const run_health_consult_js_1 = require("../medic/run-health-consult.js");
+const treatment_packets_js_1 = require("../medic/treatment-packets.js");
 function createMedicCommand(options = {}) {
     const repoRootDefault = options.repoRoot ?? (0, node_path_1.resolve)(process.cwd());
     const medic = new commander_1.Command("medic")
@@ -34,6 +38,67 @@ function createMedicCommand(options = {}) {
             process.exit(1);
         }
     }));
+    medic
+        .command("run-health-consult")
+        .description("Run a Medic run-health consult from a packet file")
+        .requiredOption("--packet-file <path>", "Path to MedicRunHealthPacket JSON")
+        .option("-r, --repo-root <path>", "Repository root", repoRootDefault)
+        .action(async (cmdOptions) => {
+        const repoRoot = cmdOptions.repoRoot;
+        let packet;
+        try {
+            packet = JSON.parse((0, node_fs_1.readFileSync)(cmdOptions.packetFile, "utf-8"));
+        }
+        catch (err) {
+            process.stderr.write(`medic run-health-consult error: cannot read packet: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+            return;
+        }
+        if (packet.role !== "medic-run-health") {
+            process.stderr.write(`medic run-health-consult error: packet role must be \"medic-run-health\", got \"${packet.role}\"\n`);
+            process.exit(1);
+            return;
+        }
+        const config = (0, loader_js_1.loadConfig)(repoRoot);
+        const adapter = new terminal_cli_js_1.TerminalCliAdapter(config.execution);
+        // Use shared provider resolution logic: prefer rotation, fall back to first provider
+        const providerName = (config.execution.rotation && config.execution.rotation.length > 0)
+            ? config.execution.rotation[0]
+            : Object.keys(config.execution.providers ?? {})[0] ?? "terminal-cli";
+        // Get current branch from git
+        let branch = "main";
+        try {
+            const { execFileSync } = require("node:child_process");
+            branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+                cwd: repoRoot,
+                encoding: "utf-8",
+            }).trim();
+        }
+        catch {
+            // Fall back to main if git fails
+        }
+        try {
+            const result = await (0, run_health_consult_js_1.runMedicRunHealthConsult)({
+                packet,
+                repoRoot,
+                stateFile: packet.cluster_state_path,
+                telemetryFile: packet.telemetry_path,
+                branch,
+                dryRun: false,
+                dispatchTreatmentWorkerFn: (input) => (0, treatment_packets_js_1.dispatchTreatmentWorker)({
+                    ...input,
+                    repoRoot,
+                    dispatch: (workerPacket) => adapter.dispatch(workerPacket, { provider: providerName }),
+                }),
+            });
+            (0, node_fs_1.writeFileSync)(packet.result_path, JSON.stringify(result, null, 2), "utf-8");
+            process.stdout.write(`Medic run-health consult result written to ${packet.result_path}\n`);
+        }
+        catch (err) {
+            process.stderr.write(`medic run-health-consult error: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    });
     return medic;
 }
 function createChart(options) {

package/dist/cluster-state/store.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.recordQcRun = exports.initializeClusterState = exports.writeClusterStateSync = exports.writeClusterState = exports.readClusterStateSync = exports.readClusterState = void 0;
 exports.pruneExpiredClaims = pruneExpiredClaims;
+exports.pruneMissingQcRunPointers = pruneMissingQcRunPointers;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const local_graph_1 = require("../tracker/local-graph");
@@ -350,12 +351,25 @@ const recordQcRun = async (clusterId, result, repoRoot) => {
     if (!currentState) {
         throw new Error(`Cluster ${clusterId} state not found; cannot record QC run ${result.qcRunId}.`);
     }
+    const rawArtifactPaths = result.rawArtifactPaths ?? [];
+    const providerAttemptPath = result.providerAttempt?.rawOutputArtifactPath;
+    const auditArtifactPaths = providerAttemptPath
+        ? [...rawArtifactPaths, providerAttemptPath]
+        : rawArtifactPaths;
+    const failedRun = result.status === "failed" || result.status === "blocked" || result.allProvidersFailed === true;
+    let availability = "available";
+    if (failedRun && auditArtifactPaths.some((p) => !(0, fs_1.existsSync)(p))) {
+        availability = "unavailable";
+    }
     const pointer = {
         artifact_path: artifactPath,
         status: result.status,
         provider: result.provider,
         started_at: result.startedAt,
         completed_at: result.completedAt,
+        availability,
+        raw_artifact_paths: rawArtifactPaths.length > 0 ? rawArtifactPaths : undefined,
+        provider_attempt_artifact_path: providerAttemptPath,
     };
     const nextState = {
         ...currentState,
@@ -369,3 +383,45 @@ const recordQcRun = async (clusterId, result, repoRoot) => {
     return { artifactPath, state: nextState };
 };
 exports.recordQcRun = recordQcRun;
+/**
+ * Remove QC run pointers whose primary artifacts are missing and mark
+ * pointers with missing raw audit artifacts as unavailable. Returns a new
+ * state object; callers must persist the result if they want the cleanup to
+ * be durable.
+ */
+function pruneMissingQcRunPointers(state) {
+    const warnings = [];
+    const pruned = [];
+    if (!state.qc_runs) {
+        return { state, pruned, warnings };
+    }
+    const validation = (0, artifacts_js_1.validateQcArtifactPointers)(state.qc_runs);
+    if (validation.ok && validation.unavailable.length === 0) {
+        return { state, pruned, warnings };
+    }
+    const nextQcRuns = {};
+    for (const [runId, pointer] of Object.entries(state.qc_runs)) {
+        if (validation.missing.includes(pointer.artifact_path)) {
+            pruned.push(runId);
+            warnings.push(`QC run ${runId} pointer pruned: artifact missing ${pointer.artifact_path}`);
+            continue;
+        }
+        const updated = { ...pointer };
+        const hasMissingRaw = (pointer.raw_artifact_paths ?? []).some((p) => validation.unavailable.includes(p)) ||
+            (pointer.provider_attempt_artifact_path &&
+                validation.unavailable.includes(pointer.provider_attempt_artifact_path));
+        if (hasMissingRaw && updated.availability === "available") {
+            updated.availability = "unavailable";
+            warnings.push(`QC run ${runId} raw audit artifacts missing; marked unavailable`);
+        }
+        nextQcRuns[runId] = updated;
+    }
+    return {
+        state: {
+            ...state,
+            qc_runs: nextQcRuns,
+        },
+        pruned,
+        warnings,
+    };
+}

package/dist/config/defaults.js

@@ -55,6 +55,9 @@ exports.DEFAULT_CONFIG = {
         requireMapValidation: true,
         requireSchemaValidation: true,
         archiveRunSnapshot: true,
+        medic: {
+            bypassPolicy: "none",
+        },
     },
     tracker: {
         lifecyclePolicy: {

package/dist/config/validator.js

@@ -548,6 +548,20 @@ function validateConfig(config) {
                     result.errors.push("finalize.archiveRunSnapshot must be a boolean");
                 }
             }
+            if ("medic" in config.finalize && config.finalize.medic !== undefined) {
+                if (!isPlainObject(config.finalize.medic)) {
+                    result.valid = false;
+                    result.errors.push("finalize.medic must be an object");
+                }
+                else {
+                    if ("bypassPolicy" in config.finalize.medic && config.finalize.medic.bypassPolicy !== undefined) {
+                        if (!isString(config.finalize.medic.bypassPolicy) || !["none", "cli"].includes(config.finalize.medic.bypassPolicy)) {
+                            result.valid = false;
+                            result.errors.push('finalize.medic.bypassPolicy must be one of "none" or "cli"');
+                        }
+                    }
+                }
+            }
         }
     }
     // tracker
@@ -1197,6 +1211,128 @@ function validateConfig(config) {
             }
         }
     }
+    // run_health
+    if ("run_health" in config && config.run_health !== undefined) {
+        if (!isPlainObject(config.run_health)) {
+            result.valid = false;
+            result.errors.push("run_health must be an object");
+        }
+        else {
+            if ("foreman_symptoms" in config.run_health && config.run_health.foreman_symptoms !== undefined) {
+                if (!isPlainObject(config.run_health.foreman_symptoms)) {
+                    result.valid = false;
+                    result.errors.push("run_health.foreman_symptoms must be an object");
+                }
+                else {
+                    if ("enabled" in config.run_health.foreman_symptoms && config.run_health.foreman_symptoms.enabled !== undefined) {
+                        if (!isBoolean(config.run_health.foreman_symptoms.enabled)) {
+                            result.valid = false;
+                            result.errors.push("run_health.foreman_symptoms.enabled must be a boolean");
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // sol
+    if ("sol" in config && config.sol !== undefined) {
+        if (!isPlainObject(config.sol)) {
+            result.valid = false;
+            result.errors.push("sol must be an object");
+        }
+        else {
+            if ("history" in config.sol && config.sol.history !== undefined) {
+                if (!isPlainObject(config.sol.history)) {
+                    result.valid = false;
+                    result.errors.push("sol.history must be an object");
+                }
+                else {
+                    if ("enabled" in config.sol.history && config.sol.history.enabled !== undefined) {
+                        if (!isBoolean(config.sol.history.enabled)) {
+                            result.valid = false;
+                            result.errors.push("sol.history.enabled must be a boolean");
+                        }
+                    }
+                    if ("path" in config.sol.history && config.sol.history.path !== undefined) {
+                        if (!isString(config.sol.history.path)) {
+                            result.valid = false;
+                            result.errors.push("sol.history.path must be a string");
+                        }
+                    }
+                }
+            }
+            if ("thresholds" in config.sol && config.sol.thresholds !== undefined) {
+                if (!isPlainObject(config.sol.thresholds)) {
+                    result.valid = false;
+                    result.errors.push("sol.thresholds must be an object");
+                }
+                else {
+                    if ("enabled" in config.sol.thresholds && config.sol.thresholds.enabled !== undefined) {
+                        if (!isBoolean(config.sol.thresholds.enabled)) {
+                            result.valid = false;
+                            result.errors.push("sol.thresholds.enabled must be a boolean");
+                        }
+                    }
+                    if ("policy" in config.sol.thresholds && config.sol.thresholds.policy !== undefined) {
+                        if (!isPlainObject(config.sol.thresholds.policy)) {
+                            result.valid = false;
+                            result.errors.push("sol.thresholds.policy must be an object");
+                        }
+                        else {
+                            if ("createRunHealthReport" in config.sol.thresholds.policy && config.sol.thresholds.policy.createRunHealthReport !== undefined) {
+                                if (!isBoolean(config.sol.thresholds.policy.createRunHealthReport)) {
+                                    result.valid = false;
+                                    result.errors.push("sol.thresholds.policy.createRunHealthReport must be a boolean");
+                                }
+                            }
+                            if ("requireMedic" in config.sol.thresholds.policy && config.sol.thresholds.policy.requireMedic !== undefined) {
+                                if (!isBoolean(config.sol.thresholds.policy.requireMedic)) {
+                                    result.valid = false;
+                                    result.errors.push("sol.thresholds.policy.requireMedic must be a boolean");
+                                }
+                            }
+                        }
+                    }
+                    if ("low_composite_score" in config.sol.thresholds && config.sol.thresholds.low_composite_score !== undefined) {
+                        if (!isNumber(config.sol.thresholds.low_composite_score) || !inRange(config.sol.thresholds.low_composite_score, 0, 1)) {
+                            result.valid = false;
+                            result.errors.push("sol.thresholds.low_composite_score must be a number between 0 and 1");
+                        }
+                    }
+                    if ("qc_repair_loop_failure_statuses" in config.sol.thresholds && config.sol.thresholds.qc_repair_loop_failure_statuses !== undefined) {
+                        if (!isStringArray(config.sol.thresholds.qc_repair_loop_failure_statuses)) {
+                            result.valid = false;
+                            result.errors.push("sol.thresholds.qc_repair_loop_failure_statuses must be an array of strings");
+                        }
+                    }
+                    if ("repeated_provider_failures" in config.sol.thresholds && config.sol.thresholds.repeated_provider_failures !== undefined) {
+                        if (!isPositiveInteger(config.sol.thresholds.repeated_provider_failures)) {
+                            result.valid = false;
+                            result.errors.push("sol.thresholds.repeated_provider_failures must be a positive integer");
+                        }
+                    }
+                    if ("foreman_intervention_count" in config.sol.thresholds && config.sol.thresholds.foreman_intervention_count !== undefined) {
+                        if (!isNonNegativeInteger(config.sol.thresholds.foreman_intervention_count)) {
+                            result.valid = false;
+                            result.errors.push("sol.thresholds.foreman_intervention_count must be a non-negative integer");
+                        }
+                    }
+                    if ("stale_wrong_run_telemetry" in config.sol.thresholds && config.sol.thresholds.stale_wrong_run_telemetry !== undefined) {
+                        if (!isBoolean(config.sol.thresholds.stale_wrong_run_telemetry)) {
+                            result.valid = false;
+                            result.errors.push("sol.thresholds.stale_wrong_run_telemetry must be a boolean");
+                        }
+                    }
+                    if ("validation_failures" in config.sol.thresholds && config.sol.thresholds.validation_failures !== undefined) {
+                        if (!isNonNegativeInteger(config.sol.thresholds.validation_failures)) {
+                            result.valid = false;
+                            result.errors.push("sol.thresholds.validation_failures must be a non-negative integer");
+                        }
+                    }
+                }
+            }
+        }
+    }
     // unknown top-level fields -> warnings
     const knownKeys = new Set([
         "version",
@@ -1213,6 +1349,11 @@ function validateConfig(config) {
         "budget",
         "compact",
         "qc",
+        "sol",
+        "run_health",
+        "orchestration",
+        "skill_packet",
+        "simplicity",
     ]);
     for (const key of Object.keys(config)) {
         if (!knownKeys.has(key)) {

package/dist/finalize/artifact-policy.js

@@ -37,6 +37,7 @@ function isPromotedClusterArtifact(relativePath, activeClusterId) {
     const suffix = relativePath.slice(activeClusterPrefix.length);
     return (suffix === "clusters.json"
         || suffix === "cluster-state.json"
+        || suffix === "state.json"
         || suffix.startsWith("packets/")
         || suffix.startsWith("results/")
         || suffix.startsWith("qc/"));
@@ -131,6 +132,7 @@ function getArtifactPromotionPolicy(activeClusterId) {
         promoted: [
             `${activeClusterPrefix}clusters.json`,
             `${activeClusterPrefix}cluster-state.json`,
+            `${activeClusterPrefix}state.json`,
             `${activeClusterPrefix}packets/**`,
             `${activeClusterPrefix}results/**`,
             `${activeClusterPrefix}qc/**`,

package/dist/finalize/github.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPrBody = buildPrBody;
 exports.createDraftPr = createDraftPr;
 const node_child_process_1 = require("node:child_process");
+function buildPrBody(state, branch, authoritativeChildCount) {
+    return [
+        `**Cluster ID:** ${state.cluster_id}`,
+        `**Run ID:** ${state.run_id}`,
+        `**Branch:** ${branch}`,
+        `**Children completed:** ${authoritativeChildCount ?? state.completed_children.length}`,
+        ``,
+        `_Generated by polaris finalize_`,
+    ].join("\n");
+}
 function createDraftPr(options) {
-    const { repoRoot, branch, state, draft } = options;
+    const { repoRoot, branch, state, draft, authoritativeChildCount } = options;
     if (!state.cluster_id) {
         throw new Error(`createDraftPr: state.cluster_id is empty — cannot create PR without a cluster identifier`);
     }
@@ -16,14 +27,7 @@ function createDraftPr(options) {
             `branch/cluster mismatch, aborting PR creation`);
     }
     const title = `polaris finalize: ${state.cluster_id} (${state.run_id})`;
-    const body = [
-        `**Cluster ID:** ${state.cluster_id}`,
-        `**Run ID:** ${state.run_id}`,
-        `**Branch:** ${branch}`,
-        `**Children completed:** ${state.completed_children.length}`,
-        ``,
-        `_Generated by polaris finalize_`,
-    ].join("\n");
+    const body = buildPrBody(state, branch, authoritativeChildCount);
     const args = [
         "pr", "create",
         "--title", title,