@lsctech/polaris 0.5.7 → 0.5.9

package/dist/run-health/index.js

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunHealthDir = getRunHealthDir;
+exports.getRunHealthReportPath = getRunHealthReportPath;
+exports.getRunHealthMarkdownPath = getRunHealthMarkdownPath;
+exports.readRunHealthReport = readRunHealthReport;
+exports.createRunHealthReport = createRunHealthReport;
+exports.appendSymptom = appendSymptom;
+exports.markBypassed = markBypassed;
+exports.markMedicDecision = markMedicDecision;
+exports.upsertWorkerSymptoms = upsertWorkerSymptoms;
+exports.isMedicGateSatisfied = isMedicGateSatisfied;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const schema_js_1 = require("./schema.js");
+// ──────────────────────────────────────────────
+// Path resolution
+// ──────────────────────────────────────────────
+/**
+ * Returns the directory that contains the run-health report for a given run.
+ * Active reports live under .polaris/runs/<run-id>/
+ */
+function getRunHealthDir(runId, repoRoot) {
+    return (0, node_path_1.join)(repoRoot ?? process.cwd(), ".polaris", "runs", runId);
+}
+/**
+ * Returns the absolute path to the run-health JSON report.
+ * The file is created on demand; its absence means no symptoms occurred.
+ */
+function getRunHealthReportPath(runId, repoRoot) {
+    return (0, node_path_1.join)(getRunHealthDir(runId, repoRoot), "run-health-report.json");
+}
+/**
+ * Returns the optional Markdown sibling path for operator review.
+ * The .md file is never required for machine consumption.
+ */
+function getRunHealthMarkdownPath(runId, repoRoot) {
+    return (0, node_path_1.join)(getRunHealthDir(runId, repoRoot), "run-health-report.md");
+}
+// ──────────────────────────────────────────────
+// Atomic write helper
+// ──────────────────────────────────────────────
+function writeJsonAtomic(filePath, data) {
+    const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        (0, node_fs_1.writeFileSync)(tempPath, JSON.stringify(data, null, 2), "utf-8");
+        (0, node_fs_1.renameSync)(tempPath, filePath);
+    }
+    catch (err) {
+        try {
+            (0, node_fs_1.unlinkSync)(tempPath);
+        }
+        catch {
+            // Ignore cleanup failure.
+        }
+        throw err;
+    }
+}
+// ──────────────────────────────────────────────
+// Read
+// ──────────────────────────────────────────────
+/**
+ * Read the run-health report for a given run.
+ * Returns null when no symptoms have been recorded (file absent or unreadable).
+ * Throws if the file exists but fails schema validation — this indicates
+ * a corrupt artifact that must not be silently ignored.
+ */
+function readRunHealthReport(runId, repoRoot) {
+    const filePath = getRunHealthReportPath(runId, repoRoot);
+    if (!(0, node_fs_1.existsSync)(filePath))
+        return null;
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(filePath, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+    const parsed = JSON.parse(raw);
+    const validation = (0, schema_js_1.validateRunHealthReport)(parsed);
+    if (!validation.valid) {
+        throw new Error(`run-health report for run "${runId}" failed schema validation:\n` +
+            validation.errors.join("\n"));
+    }
+    return parsed;
+}
+/**
+ * Create a new run-health report with the first symptom.
+ * Throws if a report already exists for this run — use appendSymptom instead.
+ * Returns the created report (immutable copy).
+ */
+function createRunHealthReport(params) {
+    const { runId, clusterId, firstSymptom, evidenceRefs, sourceActor, repoRoot } = params;
+    const filePath = getRunHealthReportPath(runId, repoRoot);
+    if ((0, node_fs_1.existsSync)(filePath)) {
+        throw new Error(`run-health report already exists for run "${runId}" — use appendSymptom to add symptoms`);
+    }
+    const now = new Date().toISOString();
+    const report = {
+        schema_version: schema_js_1.SCHEMA_VERSION,
+        run_id: runId,
+        cluster_id: clusterId,
+        symptoms: [firstSymptom],
+        evidence_refs: evidenceRefs ?? [],
+        created_at: now,
+        updated_at: now,
+        source_actor: sourceActor,
+    };
+    const validation = (0, schema_js_1.validateRunHealthReport)(report);
+    if (!validation.valid) {
+        throw new Error(`Invalid run-health report:\n${validation.errors.join("\n")}`);
+    }
+    (0, node_fs_1.mkdirSync)(getRunHealthDir(runId, repoRoot), { recursive: true });
+    writeJsonAtomic(filePath, report);
+    return Object.freeze({ ...report });
+}
+// ──────────────────────────────────────────────
+// Append
+// ──────────────────────────────────────────────
+/**
+ * Append a symptom to an existing run-health report.
+ * Creates the report if it does not exist (convenience overload — callers
+ * may use createRunHealthReport for explicit first-write semantics).
+ * Returns the updated report (immutable copy).
+ */
+function appendSymptom(runId, symptom, repoRoot) {
+    const filePath = getRunHealthReportPath(runId, repoRoot);
+    const existing = readRunHealthReport(runId, repoRoot);
+    if (!existing) {
+        throw new Error(`No run-health report found for run "${runId}" — use createRunHealthReport first`);
+    }
+    const updated = {
+        ...existing,
+        symptoms: [...existing.symptoms, symptom],
+        updated_at: new Date().toISOString(),
+    };
+    const validation = (0, schema_js_1.validateRunHealthReport)(updated);
+    if (!validation.valid) {
+        throw new Error(`Appended symptom produces invalid report:\n${validation.errors.join("\n")}`);
+    }
+    writeJsonAtomic(filePath, updated);
+    return Object.freeze({ ...updated });
+}
+// ──────────────────────────────────────────────
+// Mark bypassed
+// ──────────────────────────────────────────────
+/**
+ * Record that policy gates based on this report have been explicitly bypassed.
+ * Idempotent: re-calling with the same reason overwrites the bypass metadata.
+ * Returns the updated report (immutable copy).
+ */
+function markBypassed(runId, bypass, repoRoot) {
+    const filePath = getRunHealthReportPath(runId, repoRoot);
+    const existing = readRunHealthReport(runId, repoRoot);
+    if (!existing) {
+        throw new Error(`No run-health report found for run "${runId}"`);
+    }
+    const updated = {
+        ...existing,
+        policy_bypass: bypass,
+        updated_at: new Date().toISOString(),
+    };
+    const validation = (0, schema_js_1.validateRunHealthReport)(updated);
+    if (!validation.valid) {
+        throw new Error(`Policy bypass produces invalid report:\n${validation.errors.join("\n")}`);
+    }
+    writeJsonAtomic(filePath, updated);
+    return Object.freeze({ ...updated });
+}
+/**
+ * Record the Medic consult status and associated artifact references.
+ * Merges with any existing consult metadata (chart/treatment refs are additive).
+ * Returns the updated report (immutable copy).
+ */
+function markMedicDecision(runId, decision, repoRoot) {
+    const filePath = getRunHealthReportPath(runId, repoRoot);
+    const existing = readRunHealthReport(runId, repoRoot);
+    if (!existing) {
+        throw new Error(`No run-health report found for run "${runId}"`);
+    }
+    const prevConsult = existing.medic_consult;
+    const mergedConsult = {
+        status: decision.status,
+        chart_refs: [
+            ...(prevConsult?.chart_refs ?? []),
+            ...(decision.chartRefs ?? []),
+        ],
+        treatment_packet_refs: [
+            ...(prevConsult?.treatment_packet_refs ?? []),
+            ...(decision.treatmentPacketRefs ?? []),
+        ],
+        resolved_at: decision.resolvedAt ?? prevConsult?.resolved_at,
+        resolution_notes: decision.resolutionNotes ?? prevConsult?.resolution_notes,
+    };
+    const updated = {
+        ...existing,
+        medic_consult: mergedConsult,
+        updated_at: new Date().toISOString(),
+    };
+    const validation = (0, schema_js_1.validateRunHealthReport)(updated);
+    if (!validation.valid) {
+        throw new Error(`Medic decision produces invalid report:\n${validation.errors.join("\n")}`);
+    }
+    writeJsonAtomic(filePath, updated);
+    return Object.freeze({ ...updated });
+}
+/**
+ * Ingest worker-reported symptoms into the run-health report.
+ *
+ * Creates the report when one does not yet exist; appends to it when one does.
+ * No-ops when `symptoms` is empty — no report is created or modified.
+ * Returns the updated report, or null when no symptoms were provided.
+ */
+function upsertWorkerSymptoms(params) {
+    const { runId, clusterId, childId, workerId, provider, symptoms, repoRoot } = params;
+    if (!symptoms || symptoms.length === 0)
+        return null;
+    const sourceActor = {
+        role: "worker",
+        child_id: childId,
+        worker_id: workerId,
+        provider,
+    };
+    const existing = readRunHealthReport(runId, repoRoot);
+    const offset = existing?.symptoms.length ?? 0;
+    const toRunHealthSymptom = (s, index) => ({
+        // Stable id: child + category + (offset + index) so repeated calls don't collide
+        id: `${childId}:${s.category}:${offset + index}`,
+        severity: mapCategoryToSeverity(s.category),
+        code: s.category,
+        message: s.message,
+        source_actor: sourceActor,
+        evidence_refs: s.evidence_refs ?? [],
+        occurred_at: s.occurred_at,
+    });
+    if (!existing) {
+        const [first, ...rest] = symptoms.map(toRunHealthSymptom);
+        const report = createRunHealthReport({
+            runId,
+            clusterId,
+            firstSymptom: first,
+            sourceActor,
+            repoRoot,
+        });
+        return rest.reduce((acc, sym) => appendSymptom(runId, sym, repoRoot), report);
+    }
+    return symptoms
+        .map(toRunHealthSymptom)
+        .reduce((acc, sym) => appendSymptom(runId, sym, repoRoot), existing);
+}
+/**
+ * Maps a worker symptom category to a run-health severity level.
+ * Category-to-severity is intentionally opinionated but not final —
+ * Medic may re-classify during triage.
+ */
+function mapCategoryToSeverity(category) {
+    switch (category) {
+        case 'worker-blocked': return 'high';
+        case 'validation-failed': return 'high';
+        case 'repeated-rework': return 'medium';
+        case 'unclear-requirements': return 'medium';
+        case 'unusual-assumption': return 'low';
+        default: return 'medium';
+    }
+}
+// ──────────────────────────────────────────────
+// Re-export schema types and validation for consumers
+// ──────────────────────────────────────────────
+/**
+ * Returns true when a run-health report has a satisfied Medic gate:
+ * either a resolved/bypassed decision, or an explicit policy bypass.
+ * Used by both loop/parent.ts and finalize/medic-gate.ts to ensure
+ * consistent gate evaluation.
+ */
+function isMedicGateSatisfied(report) {
+    const status = report.medic_consult?.status;
+    if (status === "resolved" || status === "bypassed")
+        return true;
+    if (report.policy_bypass)
+        return true;
+    return false;
+}
+__exportStar(require("./schema.js"), exports);
+__exportStar(require("./foreman-symptoms.js"), exports);
+__exportStar(require("./qc-escalation.js"), exports);

package/dist/run-health/qc-escalation.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * QC escalation criteria → run-health evidence refs.
+ *
+ * QC providers are artifact producers only; they never write to the
+ * run-health report directly. This module is called by Foreman/orchestration
+ * code after QC results are available, and it determines which results meet
+ * escalation criteria before appending evidence-referenced symptoms to the
+ * run-health report.
+ *
+ * Escalation criteria:
+ *   - blocking findings (policyDecision.blocksDelivery)
+ *   - repeated findings after repair (findings present in a post-repair rerun)
+ *   - unusable output (failureReason: "unusable-output")
+ *   - parse failure (parserResult: "failed")
+ *   - all providers failed (allProvidersFailed flag)
+ *   - noisy provider output (large findings count with no blocking finding)
+ *   - max repair rounds exhausted
+ *   - repair-loop dispatch failures (medic-referral outcome)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendQcEscalationSymptoms = appendQcEscalationSymptoms;
+exports.appendRepairLoopOutcomeSymptom = appendRepairLoopOutcomeSymptom;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("./index.js");
+/**
+ * Threshold for "noisy output": more than this many findings without a
+ * blocking finding is classified as noisy.
+ */
+const NOISY_FINDINGS_THRESHOLD = 20;
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function makeQcSourceActor() {
+    return { role: "foreman" };
+}
+function makeQcSymptom(code, message, evidenceRefs) {
+    return {
+        id: `qc:${code}:${(0, node_crypto_1.randomUUID)()}`,
+        severity: qcEscalationSeverity(code),
+        code,
+        message,
+        source_actor: makeQcSourceActor(),
+        evidence_refs: evidenceRefs,
+        occurred_at: new Date().toISOString(),
+    };
+}
+function qcEscalationSeverity(code) {
+    switch (code) {
+        case "qc-blocking-findings":
+        case "qc-all-providers-failed":
+        case "qc-repair-dispatch-failure":
+            return "high";
+        case "qc-repeated-findings":
+        case "qc-parse-failure":
+        case "qc-unusable-output":
+        case "qc-max-repair-rounds":
+            return "medium";
+        case "qc-noisy-output":
+            return "low";
+        default:
+            return "medium";
+    }
+}
+function upsertQcSymptom(runId, clusterId, symptom, repoRoot) {
+    try {
+        const existing = (0, index_js_1.readRunHealthReport)(runId, repoRoot);
+        if (!existing) {
+            (0, index_js_1.createRunHealthReport)({
+                runId,
+                clusterId,
+                firstSymptom: symptom,
+                sourceActor: makeQcSourceActor(),
+                repoRoot,
+            });
+        }
+        else {
+            (0, index_js_1.appendSymptom)(runId, symptom, repoRoot);
+        }
+    }
+    catch {
+        // QC escalation must never block the run.
+        // ponytail: surface to telemetry in a future pass
+    }
+}
+/**
+ * Evaluate QC results against escalation criteria and append any matching
+ * symptoms to the run-health report.
+ *
+ * No-ops when no escalation criteria are met.
+ * Never throws.
+ */
+function appendQcEscalationSymptoms(params) {
+    const { runId, clusterId, qcResults, afterRepair = false, repoRoot } = params;
+    // Collect artifact paths as evidence refs for each result.
+    const allEvidenceRefs = qcResults.flatMap((r) => r.rawArtifactPaths ?? []);
+    // ── All providers failed ───────────────────────────────────────────────────
+    const allFailed = qcResults.length > 0 && qcResults.every((r) => r.allProvidersFailed || r.status === "failed");
+    if (allFailed) {
+        upsertQcSymptom(runId, clusterId, makeQcSymptom("qc-all-providers-failed", `All QC providers failed (${qcResults.length} provider(s)); no review was performed.`, allEvidenceRefs), repoRoot);
+        return; // If all providers failed, other criteria cannot be evaluated reliably.
+    }
+    for (const result of qcResults) {
+        const evidenceRefs = result.rawArtifactPaths ?? [];
+        // ── Parse failure ──────────────────────────────────────────────────────
+        if (result.providerAttempt?.parserResult === "failed") {
+            upsertQcSymptom(runId, clusterId, makeQcSymptom("qc-parse-failure", `QC provider "${result.provider}" output could not be parsed (qcRunId: ${result.qcRunId}).`, evidenceRefs), repoRoot);
+            continue; // No findings to evaluate from a failed parse.
+        }
+        // ── Unusable output ────────────────────────────────────────────────────
+        if (result.providerAttempt?.failureReason === "unusable-output" ||
+            result.providerAttempt?.failureReason === "empty-output") {
+            upsertQcSymptom(runId, clusterId, makeQcSymptom("qc-unusable-output", `QC provider "${result.provider}" produced unusable output (reason: ${result.providerAttempt.failureReason}).`, evidenceRefs), repoRoot);
+            continue;
+        }
+        // ── Blocking findings ──────────────────────────────────────────────────
+        if (result.policyDecision?.blocksDelivery) {
+            const blockingCount = result.findings.filter((f) => f.status === "open" || f.status === "follow-up").length;
+            upsertQcSymptom(runId, clusterId, makeQcSymptom("qc-blocking-findings", `QC provider "${result.provider}" has ${blockingCount} blocking finding(s) that prevent delivery (qcRunId: ${result.qcRunId}).`, evidenceRefs), repoRoot);
+        }
+        // ── Repeated findings after repair ─────────────────────────────────────
+        if (afterRepair && result.findings.some((f) => f.status === "open")) {
+            const repeatedCount = result.findings.filter((f) => f.status === "open").length;
+            upsertQcSymptom(runId, clusterId, makeQcSymptom("qc-repeated-findings", `QC provider "${result.provider}" still shows ${repeatedCount} open finding(s) after repair (qcRunId: ${result.qcRunId}).`, evidenceRefs), repoRoot);
+        }
+        // ── Noisy provider output ──────────────────────────────────────────────
+        if (result.findings.length > NOISY_FINDINGS_THRESHOLD &&
+            !result.policyDecision?.blocksDelivery) {
+            upsertQcSymptom(runId, clusterId, makeQcSymptom("qc-noisy-output", `QC provider "${result.provider}" produced ${result.findings.length} findings (>${NOISY_FINDINGS_THRESHOLD} threshold) without a blocking policy decision — possible noise.`, evidenceRefs), repoRoot);
+        }
+    }
+}
+/**
+ * Append run-health symptoms for non-passing QC repair loop outcomes.
+ *
+ * Handles: max-rounds, medic-referral (repair dispatch failure), all-providers-failed.
+ * The pass/no-repairable/qc-disabled/operator-review outcomes produce no symptoms.
+ * Never throws.
+ */
+function appendRepairLoopOutcomeSymptom(params) {
+    const { runId, clusterId, repairResult, repoRoot } = params;
+    const evidenceRefs = repairResult.final_qc_results.flatMap((r) => r.rawArtifactPaths ?? []);
+    switch (repairResult.outcome) {
+        case "max-rounds":
+            upsertQcSymptom(runId, clusterId, makeQcSymptom("qc-max-repair-rounds", `QC repair loop exhausted max rounds (${repairResult.rounds_completed}) without passing: ${repairResult.summary}`, evidenceRefs), repoRoot);
+            break;
+        case "medic-referral":
+            upsertQcSymptom(runId, clusterId, makeQcSymptom("qc-repair-dispatch-failure", `QC repair loop terminated with Medic referral after ${repairResult.rounds_completed} round(s) — repair worker(s) failed: ${repairResult.summary}`, evidenceRefs), repoRoot);
+            break;
+        case "all-providers-failed":
+            upsertQcSymptom(runId, clusterId, makeQcSymptom("qc-all-providers-failed", `All QC providers failed during repair loop (rounds: ${repairResult.rounds_completed}): ${repairResult.summary}`, evidenceRefs), repoRoot);
+            break;
+        // pass, no-repairable, qc-disabled, operator-review — no symptom needed
+        default:
+            break;
+    }
+}

package/dist/run-health/schema.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunHealthReport = exports.MedicConsult = exports.MedicConsultStatus = exports.PolicyBypassMetadata = exports.RunHealthSymptom = exports.SourceActor = exports.SymptomSeverity = exports.SCHEMA_VERSION = void 0;
+exports.validateRunHealthReport = validateRunHealthReport;
+const zod_1 = require("zod");
+/**
+ * Run-health report schema — v1.
+ *
+ * The run-health report is the canonical artifact for recording symptoms that
+ * occur during a Polaris run. It is the single source of truth used by workers,
+ * Foreman, closeout, SOL, and Medic.
+ *
+ * Design rules:
+ *   - Report is ONLY created when at least one symptom occurs (YAGNI).
+ *   - JSON is the machine-readable source of truth; optional .md sibling for
+ *     operator review.
+ *   - QC artifacts are referenced by path/id only — QC never writes symptoms.
+ *   - All mutations use atomic temp-file + rename to avoid partial writes.
+ */
+exports.SCHEMA_VERSION = "1";
+// ──────────────────────────────────────────────
+// Sub-schemas
+// ──────────────────────────────────────────────
+exports.SymptomSeverity = zod_1.z.enum(["critical", "high", "medium", "low"]);
+exports.SourceActor = zod_1.z.object({
+    /** Polaris role: worker, foreman, medic, etc. */
+    role: zod_1.z.string().min(1),
+    /** Child task id when emitted from a worker or child session. */
+    child_id: zod_1.z.string().optional(),
+    /** Worker instance id from dispatch record. */
+    worker_id: zod_1.z.string().optional(),
+    /** Provider name (e.g. "devin", "claude"). */
+    provider: zod_1.z.string().optional(),
+});
+exports.RunHealthSymptom = zod_1.z.object({
+    /** Unique symptom id within this report (opaque, stable across appends). */
+    id: zod_1.z.string().min(1),
+    severity: exports.SymptomSeverity,
+    /**
+     * Short machine-readable code (e.g. "build-failure", "test-regression").
+     * Consumers use this for routing; keep it stable between runs.
+     */
+    code: zod_1.z.string().min(1),
+    /** Human-readable description for operator review. */
+    message: zod_1.z.string().min(1),
+    /** Actor that observed and recorded this symptom. */
+    source_actor: exports.SourceActor,
+    /**
+     * Paths or ids of QC/evidence artifacts this symptom is based on.
+     * QC artifacts live at .polaris/clusters/<cluster-id>/qc/<qcRunId>.json.
+     * Symptom producers reference them by path; QC itself never writes here.
+     */
+    evidence_refs: zod_1.z.array(zod_1.z.string()).default([]),
+    occurred_at: zod_1.z.string().datetime(),
+});
+exports.PolicyBypassMetadata = zod_1.z.object({
+    reason: zod_1.z.string().min(1),
+    /** Actor that approved the bypass. */
+    bypassed_by: zod_1.z.string().min(1),
+    bypassed_at: zod_1.z.string().datetime(),
+});
+exports.MedicConsultStatus = zod_1.z.enum([
+    "pending",
+    "in-progress",
+    "resolved",
+    "bypassed",
+]);
+exports.MedicConsult = zod_1.z.object({
+    status: exports.MedicConsultStatus,
+    /**
+     * References to Medic chart files (CHART-YYYY-MM-DD-NNN format).
+     * Charts live under .polaris/charts/. Referenced by id/path, never embedded.
+     */
+    chart_refs: zod_1.z.array(zod_1.z.string()).default([]),
+    /**
+     * References to Medic treatment packet files.
+     * Treatment packets live under .polaris/clusters/<id>/medic/.
+     * Referenced by path, never embedded.
+     */
+    treatment_packet_refs: zod_1.z.array(zod_1.z.string()).default([]),
+    resolved_at: zod_1.z.string().datetime().optional(),
+    resolution_notes: zod_1.z.string().optional(),
+});
+// ──────────────────────────────────────────────
+// Root schema
+// ──────────────────────────────────────────────
+exports.RunHealthReport = zod_1.z.object({
+    schema_version: zod_1.z.literal(exports.SCHEMA_VERSION),
+    run_id: zod_1.z.string().min(1),
+    cluster_id: zod_1.z.string().min(1),
+    /** Ordered list of symptoms; newest appended at end. */
+    symptoms: zod_1.z.array(exports.RunHealthSymptom),
+    /**
+     * Run-level evidence refs (e.g. telemetry path, state snapshot).
+     * Individual symptoms carry their own evidence_refs; this field holds
+     * refs that apply to the report as a whole.
+     */
+    evidence_refs: zod_1.z.array(zod_1.z.string()).default([]),
+    /**
+     * Present only when an operator or SOL has explicitly bypassed policy
+     * gates based on this report. Absence means no bypass has been granted.
+     */
+    policy_bypass: exports.PolicyBypassMetadata.optional(),
+    /**
+     * Present only when Medic has been consulted. Absence means no Medic
+     * consult has occurred — closeout must not infer severity from absence.
+     */
+    medic_consult: exports.MedicConsult.optional(),
+    created_at: zod_1.z.string().datetime(),
+    updated_at: zod_1.z.string().datetime(),
+    /** Actor that created the report (first producer). */
+    source_actor: exports.SourceActor,
+});
+function validateRunHealthReport(data) {
+    const result = exports.RunHealthReport.safeParse(data);
+    if (!result.success) {
+        return {
+            valid: false,
+            errors: result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`),
+        };
+    }
+    return { valid: true, errors: [] };
+}