@skill-harness/core 0.17.0 → 0.18.0

package/dist/factory-calibration.d.ts

@@ -1,63 +0,0 @@
-export interface CalibrationComponent {
-    kind: "detector" | "adjudicator";
-    id: string;
-    version: string;
-    population: string;
-}
-export type CalibrationKind = "positive" | "approval" | "rejection";
-export type CalibrationSplit = "calibration" | "heldout" | "tuning";
-export interface CalibrationPrediction {
-    id: string;
-    incidentId: string;
-    component: CalibrationComponent;
-    kind: CalibrationKind;
-    split: CalibrationSplit;
-}
-/** Independently established host context, not fields accepted from predictions or panel agreement. */
-export interface CalibrationOutcome extends CalibrationPrediction {
-    correct: boolean;
-}
-export interface CalibrationReport {
-    component: CalibrationComponent;
-    kind: CalibrationKind;
-    split: Exclude<CalibrationSplit, "tuning">;
-    correct: number;
-    incorrect: number;
-    resolved: number;
-    unresolved: number;
-    conflicted: number;
-    totalIncidents: number;
-    precision: number | null;
-    interval: {
-        lower: number;
-        upper: number;
-    } | null;
-    advisoryOnly: true;
-}
-/** Version/population/conditioning-specific statistics; no policy, grants, routing or adoption is changed. */
-export declare function calibratePredictions(predictions: readonly CalibrationPrediction[], context?: {
-    outcomes: readonly CalibrationOutcome[];
-}): {
-    version: "factory-calibration-v1";
-    reports: CalibrationReport[];
-    excludedTuning: number;
-    referenceBasis: "independently-supplied-host-context";
-    advisoryOnly: true;
-};
-export interface ExposurePolicy {
-    id: string;
-    component: CalibrationComponent;
-    kind: CalibrationKind;
-    split: "calibration" | "heldout";
-    minimumResolved: number;
-    minimumLowerBound: number;
-    attentionRemaining: number;
-    expiresAt: number;
-    retireBelowUpperBound?: number;
-}
-/** A selected pre-established host policy may produce advice; this never applies it or expands authority. */
-export declare function recommendExposure(report: CalibrationReport, policy: ExposurePolicy | null, now: number): {
-    mode: "silent" | "ask" | "retire";
-    reason: string;
-    advisoryOnly: true;
-};

package/dist/factory-calibration.js

@@ -1,115 +0,0 @@
-const computedReports = new WeakSet();
-const text = (x) => typeof x === "string" && x.length > 0 && x.length <= 512 && !/[\u0000-\u001f\u007f]/.test(x);
-function closed(x, fields) {
-    return x !== null && typeof x === "object" && !Array.isArray(x) && Object.keys(x).length === fields.length && Object.keys(x).every(k => fields.includes(k));
-}
-function valid(x, outcome = false) {
-    return closed(x, outcome ? ["id", "incidentId", "component", "kind", "split", "correct"] : ["id", "incidentId", "component", "kind", "split"])
-        && text(x.id) && text(x.incidentId) && closed(x.component, ["kind", "id", "version", "population"])
-        && [x.component.id, x.component.version, x.component.population].every(text)
-        && ["calibration", "heldout", "tuning"].includes(x.split)
-        && (x.component.kind === "detector" ? x.kind === "positive" : x.component.kind === "adjudicator" && ["approval", "rejection"].includes(x.kind))
-        && (!outcome || typeof x.correct === "boolean");
-}
-const key = (x) => JSON.stringify([x.component.kind, x.component.id, x.component.version, x.component.population, x.kind, x.split]);
-function interval(correct, count) {
-    const z = 1.96, z2 = z * z, p = correct / count, denominator = 1 + z2 / count;
-    const center = (p + z2 / (2 * count)) / denominator;
-    const half = z * Math.sqrt(p * (1 - p) / count + z2 / (4 * count * count)) / denominator;
-    return { lower: Math.max(0, center - half), upper: Math.min(1, center + half) };
-}
-/** Version/population/conditioning-specific statistics; no policy, grants, routing or adoption is changed. */
-export function calibratePredictions(predictions, context = { outcomes: [] }) {
-    if (predictions.length > 10000 || context.outcomes.length > 10000 || predictions.some(p => !valid(p)) || context.outcomes.some(r => !valid(r, true)))
-        throw new Error("invalid calibration input");
-    const byId = new Map();
-    for (const p of predictions) {
-        const previous = byId.get(p.id);
-        if (previous && (key(previous) !== key(p) || previous.incidentId !== p.incidentId))
-            throw new Error("prediction identity conflict");
-        byId.set(p.id, p);
-    }
-    const groups = new Map();
-    let excludedTuning = 0;
-    for (const p of byId.values()) {
-        if (p.split === "tuning") {
-            excludedTuning++;
-            continue;
-        }
-        const k = key(p);
-        groups.set(k, [...(groups.get(k) ?? []), p]);
-    }
-    const referenceIds = new Map();
-    const conflictingIds = new Set();
-    for (const r of context.outcomes) {
-        const signature = JSON.stringify([key(r), r.incidentId, r.correct]);
-        if (referenceIds.has(r.id) && referenceIds.get(r.id) !== signature)
-            conflictingIds.add(r.id);
-        referenceIds.set(r.id, signature);
-    }
-    const labels = new Map();
-    const conflictedIncidents = new Set();
-    for (const r of context.outcomes) {
-        const k = JSON.stringify([key(r), r.incidentId]);
-        if (conflictingIds.has(r.id)) {
-            conflictedIncidents.add(k);
-            continue;
-        }
-        const values = labels.get(k) ?? new Set();
-        values.add(r.correct);
-        labels.set(k, values);
-    }
-    const reports = [...groups].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([groupKey, group]) => {
-        const incidents = new Set(group.map(p => p.incidentId));
-        let correct = 0, incorrect = 0, unresolved = 0, conflicted = 0;
-        for (const incident of incidents) {
-            const incidentKey = JSON.stringify([groupKey, incident]);
-            const outcomes = labels.get(incidentKey) ?? new Set();
-            if (outcomes.size !== 1 || conflictedIncidents.has(incidentKey)) {
-                unresolved++;
-                if (outcomes.size > 1 || conflictedIncidents.has(incidentKey))
-                    conflicted++;
-            }
-            else if (outcomes.has(true))
-                correct++;
-            else
-                incorrect++;
-        }
-        const resolved = correct + incorrect;
-        return { component: { ...group[0].component }, kind: group[0].kind, split: group[0].split,
-            correct, incorrect, resolved, unresolved, conflicted, totalIncidents: incidents.size,
-            precision: resolved ? correct / resolved : null, interval: resolved ? interval(correct, resolved) : null, advisoryOnly: true };
-    });
-    for (const report of reports) {
-        Object.freeze(report.component);
-        if (report.interval)
-            Object.freeze(report.interval);
-        Object.freeze(report);
-        computedReports.add(report);
-    }
-    return { version: "factory-calibration-v1", reports, excludedTuning, referenceBasis: "independently-supplied-host-context", advisoryOnly: true };
-}
-/** A selected pre-established host policy may produce advice; this never applies it or expands authority. */
-export function recommendExposure(report, policy, now) {
-    if (!computedReports.has(report))
-        throw new Error("recompute calibration from predictions and independent reference context before evaluating exposure");
-    const result = (mode, reason) => ({ mode, reason, advisoryOnly: true });
-    if (!policy)
-        return result("silent", "policy-unavailable");
-    if (!text(policy.id) || !Number.isSafeInteger(policy.minimumResolved) || policy.minimumResolved < 1
-        || !Number.isSafeInteger(policy.attentionRemaining) || policy.attentionRemaining < 0
-        || !Number.isFinite(policy.minimumLowerBound) || policy.minimumLowerBound < 0 || policy.minimumLowerBound > 1
-        || !Number.isFinite(policy.expiresAt) || !Number.isFinite(now)
-        || (policy.retireBelowUpperBound !== undefined && (!Number.isFinite(policy.retireBelowUpperBound) || policy.retireBelowUpperBound < 0 || policy.retireBelowUpperBound > 1)))
-        throw new Error("invalid exposure policy");
-    if (key(policy) !== key(report) || now >= policy.expiresAt)
-        return result("silent", "policy-inapplicable-or-expired");
-    if (!report.interval || report.resolved < policy.minimumResolved)
-        return result("silent", "insufficient-independent-evidence");
-    if (policy.retireBelowUpperBound !== undefined && report.interval.upper < policy.retireBelowUpperBound)
-        return result("retire", "below-selected-reliability-policy");
-    if (report.interval.lower < policy.minimumLowerBound || policy.attentionRemaining === 0)
-        return result("silent", "confidence-or-attention-bound");
-    return result("ask", "selected-evidence-and-attention-policy-met");
-}
-//# sourceMappingURL=factory-calibration.js.map

package/dist/intervention-results.d.ts

@@ -1,6 +0,0 @@
-import type { InterventionManifest, InterventionEvidence } from "./intervention.js";
-/** Normalize existing validated schema3 records, retaining the complete source votes alongside the summary. */
-export declare function interventionEvidenceFromResults(manifest: InterventionManifest, armId: string, raw: unknown, outputBytes: ReadonlyMap<string, Uint8Array>): {
-    evidence: InterventionEvidence;
-    sourceResults: import("./results.js").ResultsFile;
-};

package/dist/intervention-results.js

@@ -1,52 +0,0 @@
-import { createHash } from "node:crypto";
-import { validateResults } from "./results.js";
-import { aggregateMetrics } from "./comparison.js";
-/** Normalize existing validated schema3 records, retaining the complete source votes alongside the summary. */
-export function interventionEvidenceFromResults(manifest, armId, raw, outputBytes) {
-    const sourceResults = validateResults(raw), arm = manifest.arms.find(a => a.id === armId);
-    if (!arm || sourceResults.model !== arm.configuration.model)
-        throw new Error("intervention result model mismatch");
-    if (sourceResults.schema !== 3 || sourceResults.partial || sourceResults.mode !== manifest.common.mode
-        || `${sourceResults.judge.provider}:${sourceResults.judge.model}` !== manifest.judge)
-        throw new Error("incomplete or incompatible intervention results");
-    if (sourceResults.source_hashes?.["intervention:manifest"] !== manifest.id || sourceResults.source_hashes?.["intervention:inputs"] !== manifest.inputDigest)
-        throw new Error("recorded frozen intervention binding missing; never stamp historical results");
-    if (sourceResults.scenarios.length !== manifest.cases.length || sourceResults.scenarios.some(s => !manifest.cases.some(c => c.id === s.id)))
-        throw new Error("intervention scenario plan mismatch");
-    const cells = [], artifacts = new Set();
-    for (const spec of manifest.cases) {
-        const scenario = sourceResults.scenarios.find(s => s.id === spec.id);
-        if (scenario.criterion_count !== spec.criteria || (scenario.reps ?? 1) !== spec.reps || (scenario.pass_threshold ?? 1) !== spec.threshold)
-            throw new Error("intervention repetition/criterion policy mismatch");
-        for (const panel of scenario.rep_judgments ?? []) {
-            const delivery = sourceResults.subject_invocations.find(o => o.scenario_id === spec.id && o.repetition === panel.repetition)?.prompt?.status;
-            if (!delivery || !panel.objective)
-                throw new Error("intervention objective/delivery evidence missing");
-            const objective = panel.objective.status;
-            const bytes = outputBytes.get(`${spec.id}:${panel.repetition}`);
-            if (bytes !== undefined && (!(bytes instanceof Uint8Array) || bytes.byteLength > 8 * 1024 * 1024))
-                throw new Error("intervention output exceeds bounds");
-            const artifactSha256 = bytes ? createHash("sha256").update(bytes).digest("hex") : null;
-            if (artifactSha256)
-                artifacts.add(artifactSha256);
-            let criteria = [], suspect = false;
-            if (delivery === "PASS" && objective === "PASS") {
-                if (panel.judgments.length !== 1)
-                    throw new Error("multi-judge normalization not yet supported; retain original panel without selecting a convenient vote");
-                const judgment = panel.judgments[0];
-                if (`${judgment.judge.provider}:${judgment.judge.model}` !== manifest.judge)
-                    throw new Error("intervention cell judge mismatch");
-                criteria = [...(judgment.criteria ?? [])].sort((a, b) => a.index - b.index).map(c => c.verdict === "ERROR" ? "UNKNOWN" : c.verdict);
-                suspect = judgment.suspect || scenario.suspect;
-            }
-            cells.push({ caseId: spec.id, repetition: panel.repetition, delivery, objective, criteria, suspect, artifactSha256 });
-        }
-    }
-    const metrics = aggregateMetrics(sourceResults.scenarios);
-    const cost = manifest.resourceMetric === "wall_ms" ? (sourceResults.scenarios.every(s => s.metrics) ? metrics.wall_time_ms : null)
-        : manifest.resourceMetric === "tool_calls" ? metrics.tool_calls
-            : metrics.cost_source === "provider-reported" && metrics.subject_metrics_reps === metrics.total_reps ? metrics.subject_cost_usd : null;
-    const evidence = { armId, inputDigest: manifest.inputDigest, artifactDigests: [...artifacts].sort(), cells, cost, costUnit: manifest.resourceMetric };
-    return { evidence, sourceResults };
-}
-//# sourceMappingURL=intervention-results.js.map

package/dist/intervention.d.ts

@@ -1,123 +0,0 @@
-/** Plain, bounded JSON encoding for retained intervention inputs; not semantic validation. */
-export declare function interventionCanonicalJson(value: unknown): string;
-export type InterventionAxis = "model" | "effort" | "skill" | "prompt" | "configuration";
-export interface InterventionDraft {
-    family: "intervention";
-    investigationSha256: string;
-    resourceMetric: "usd" | "wall_ms" | "tool_calls";
-    axes: InterventionAxis[];
-    common: {
-        mode: "green" | "force";
-        scenarioSha256: string;
-        rubricSha256: string;
-        fixtureSha256: string;
-        heldoutSha256: string;
-        harnessSha256: string;
-        judgePolicySha256: string;
-    };
-    proposer: string;
-    judge: string;
-    cases: Array<{
-        id: string;
-        criteria: number;
-        reps: number;
-        threshold: number;
-        critical: boolean;
-    }>;
-    arms: Array<{
-        id: string;
-        configuration: Record<InterventionAxis, string>;
-    }>;
-}
-export interface InterventionManifest extends InterventionDraft {
-    version: "intervention-comparison-v1";
-    id: string;
-    inputDigest: string;
-    changedAxes: InterventionAxis[];
-    deterministicSampling: false;
-}
-export declare function freezeIntervention(input: InterventionDraft): InterventionManifest;
-export interface InterventionCell {
-    caseId: string;
-    repetition: number;
-    delivery: "PASS" | "NOT-MEASURED" | "ERROR";
-    objective: "PASS" | "FAIL" | "ERROR" | "NOT-MEASURED";
-    criteria: Array<"PASS" | "FAIL" | "UNKNOWN">;
-    suspect: boolean;
-    artifactSha256: string | null;
-}
-export interface InterventionEvidence {
-    armId: string;
-    inputDigest: string;
-    artifactDigests: string[];
-    cells: InterventionCell[];
-    cost: number | null;
-    costUnit: string;
-}
-export declare const interventionEvidenceDigest: (value: InterventionEvidence) => string;
-export interface InterventionQualification {
-    manifestId: string;
-    proposer: {
-        requested: string;
-        canonical: string;
-    };
-    judge: {
-        requested: string;
-        canonical: string;
-    };
-    subjects: Record<string, {
-        requested: string;
-        canonical: string;
-    }>;
-    evidenceDigests: Record<string, string>;
-    /** Actual independently retained output bytes, not an availability flag supplied by an arm. */
-    artifacts: ReadonlyMap<string, Uint8Array>;
-}
-export interface InterventionAssessment {
-    manifestId: string;
-    complete: boolean;
-    arms: Array<{
-        armId: string;
-        state: "MEASURED" | "FAILED" | "MISSING" | "ERROR" | "NOT-MEASURED" | "UNRESOLVED";
-        eligible: boolean;
-        artifactDigests: string[];
-        cost: number | null;
-        costUnit: string;
-    }>;
-    cheapestEligible: string | null;
-    routingDefault: null;
-    adoptionAuthorized: false;
-}
-/** Pre-spend role gate: consumes independently resolved host facts, never guesses aliases or calls a provider. */
-export declare function assertInterventionRoles(manifest: InterventionManifest, qualification: InterventionQualification | null): asserts qualification is InterventionQualification;
-/** Inspects separately host-qualified evidence; does not obtain qualification or execute a model. */
-export declare function assessIntervention(manifest: InterventionManifest, evidence: readonly InterventionEvidence[], qualification: InterventionQualification | null): InterventionAssessment;
-export type BlindQualityChoice = {
-    kind: "one" | "tie" | "none" | "insufficient";
-    labels: string[];
-};
-/** Only this view omits identity/cost; arbitrary artifact content can still leak clues and must be reviewed. */
-export declare function createBlindComparison(manifest: InterventionManifest, assessment: InterventionAssessment, fixtureOrPersistedSeed?: string): Readonly<{
-    view: () => {
-        version: string;
-        cards: {
-            label: string;
-            artifactDigests: string[];
-        }[];
-        limitations: string[];
-    };
-    readArtifact(label: string, hash: string): Buffer<ArrayBuffer>;
-    choose(input: BlindQualityChoice): BlindQualityChoice;
-    reveal(): {
-        manifestId: string;
-        choice: BlindQualityChoice;
-        arms: {
-            label: string;
-            armId: string;
-            configuration: Record<InterventionAxis, string>;
-            cost: number | null;
-            costUnit: string;
-        }[];
-        routingDefault: null;
-    };
-}>;

package/dist/intervention.js

@@ -1,218 +0,0 @@
-import { createHash, randomBytes } from "node:crypto";
-const SHA = /^[a-f0-9]{64}$/;
-const text = (x, max = 512) => typeof x === "string" && x.length > 0 && x.length <= max && !/[\u0000-\u001f\u007f]/.test(x);
-const closed = (x, names) => !!x && typeof x === "object" && !Array.isArray(x) && Object.keys(x).sort().join() === [...names].sort().join();
-function canonical(x, depth = 0) {
-    if (depth > 16)
-        throw new Error("intervention data exceeds depth");
-    if (x === null || typeof x === "string" || typeof x === "boolean" || (typeof x === "number" && Number.isFinite(x)))
-        return JSON.stringify(x);
-    if (!x || typeof x !== "object" || (!Array.isArray(x) && ![Object.prototype, null].includes(Object.getPrototypeOf(x))))
-        throw new Error("plain intervention JSON required");
-    const d = Object.getOwnPropertyDescriptors(x);
-    if (Array.isArray(x)) {
-        if (x.length > 4096 || Reflect.ownKeys(x).length !== x.length + 1)
-            throw new Error("bounded dense array required");
-        return `[${Array.from({ length: x.length }, (_, i) => { if (!d[i] || !Object.hasOwn(d[i], "value"))
-            throw new Error("plain array required"); return canonical(d[i].value, depth + 1); }).join(",")}]`;
-    }
-    return `{${Reflect.ownKeys(d).sort((a, b) => String(a) < String(b) ? -1 : 1).map(k => { if (typeof k !== "string" || !d[k].enumerable || !Object.hasOwn(d[k], "value"))
-        throw new Error("plain object required"); return `${JSON.stringify(k)}:${canonical(d[k].value, depth + 1)}`; }).join(",")}}`;
-}
-/** Plain, bounded JSON encoding for retained intervention inputs; not semantic validation. */
-export function interventionCanonicalJson(value) {
-    const bytes = canonical(value);
-    if (Buffer.byteLength(bytes) > 2 * 1024 * 1024)
-        throw new Error("intervention data exceeds byte bound");
-    return bytes;
-}
-const digest = (value) => createHash("sha256").update(interventionCanonicalJson(value)).digest("hex");
-function frozen(value) { if (value && typeof value === "object") {
-    Object.values(value).forEach(frozen);
-    Object.freeze(value);
-} return value; }
-const clone = (value) => JSON.parse(canonical(value));
-const axes = ["model", "effort", "skill", "prompt", "configuration"];
-export function freezeIntervention(input) {
-    const d = clone(input);
-    if (!closed(d, ["family", "investigationSha256", "resourceMetric", "axes", "common", "proposer", "judge", "cases", "arms"]) || d.family !== "intervention" || !SHA.test(d.investigationSha256)
-        || !["usd", "wall_ms", "tool_calls"].includes(d.resourceMetric)
-        || !Array.isArray(d.axes) || !d.axes.length || new Set(d.axes).size !== d.axes.length || d.axes.some(a => !axes.includes(a))
-        || !closed(d.common, ["mode", "scenarioSha256", "rubricSha256", "fixtureSha256", "heldoutSha256", "harnessSha256", "judgePolicySha256"])
-        || !["green", "force"].includes(d.common.mode) || Object.entries(d.common).some(([k, v]) => k !== "mode" && !SHA.test(v))
-        || !text(d.proposer) || !text(d.judge) || !Array.isArray(d.arms) || d.arms.length < 2 || d.arms.length > 8
-        || !Array.isArray(d.cases) || !d.cases.length || d.cases.length > 128)
-        throw new Error("invalid intervention manifest");
-    for (const arm of d.arms)
-        if (!closed(arm, ["id", "configuration"]) || !text(arm.id, 128) || !closed(arm.configuration, axes)
-            || !text(arm.configuration.model) || !text(arm.configuration.effort) || ["skill", "prompt", "configuration"].some(k => !SHA.test(arm.configuration[k])))
-            throw new Error("invalid intervention arm");
-    if (new Set(d.arms.map(a => a.id)).size !== d.arms.length || new Set(d.cases.map(c => c.id)).size !== d.cases.length)
-        throw new Error("duplicate intervention identity");
-    for (const c of d.cases)
-        if (!closed(c, ["id", "criteria", "reps", "threshold", "critical"]) || !text(c.id, 128)
-            || !Number.isSafeInteger(c.criteria) || c.criteria < 1 || c.criteria > 128 || !Number.isSafeInteger(c.reps) || c.reps < 1 || c.reps > 20
-            || !Number.isFinite(c.threshold) || c.threshold <= 0 || c.threshold > 1 || typeof c.critical !== "boolean"
-            || ((c.critical || c.id.startsWith("B")) && c.threshold !== 1))
-            throw new Error("invalid frozen case policy");
-    const changedAxes = axes.filter(axis => d.arms.some(a => a.configuration[axis] !== d.arms[0].configuration[axis]));
-    if (changedAxes.some(axis => !d.axes.includes(axis)))
-        throw new Error("undeclared intervention axis");
-    const body = { ...d, version: "intervention-comparison-v1", inputDigest: digest({ common: d.common, cases: d.cases }), changedAxes, deterministicSampling: false };
-    return frozen({ ...body, id: digest(body) });
-}
-export const interventionEvidenceDigest = (value) => digest(value);
-const assessments = new WeakSet();
-const assessmentArtifacts = new WeakMap();
-function manifestValid(m) {
-    const detached = clone(m);
-    const { version, id: _id, inputDigest: _inputs, changedAxes: _axes, deterministicSampling, ...draft } = detached;
-    if (version !== "intervention-comparison-v1" || deterministicSampling !== false || canonical(freezeIntervention(draft)) !== canonical(detached))
-        throw new Error("frozen intervention changed");
-}
-/** Pre-spend role gate: consumes independently resolved host facts, never guesses aliases or calls a provider. */
-export function assertInterventionRoles(manifest, qualification) {
-    manifestValid(manifest);
-    if (!qualification || !qualification.proposer || !qualification.judge || !qualification.subjects || qualification.manifestId !== manifest.id || qualification.proposer.requested !== manifest.proposer || qualification.judge.requested !== manifest.judge
-        || !text(qualification.proposer.canonical) || !text(qualification.judge.canonical))
-        throw new Error("independent role qualification required");
-    const reserved = new Set([qualification.proposer.canonical, qualification.judge.canonical]);
-    if (reserved.size !== 2 || manifest.arms.some(a => !Object.hasOwn(qualification.subjects, a.id) || qualification.subjects[a.id].requested !== a.configuration.model
-        || !text(qualification.subjects[a.id].canonical) || reserved.has(qualification.subjects[a.id].canonical)))
-        throw new Error("role identity conflict or unresolved role");
-}
-/** Inspects separately host-qualified evidence; does not obtain qualification or execute a model. */
-export function assessIntervention(manifest, evidence, qualification) {
-    assertInterventionRoles(manifest, qualification);
-    if (evidence.length > manifest.arms.length || new Set(evidence.map(e => e.armId)).size !== evidence.length || evidence.some(e => !manifest.arms.some(a => a.id === e.armId)))
-        throw new Error("unexpected intervention evidence identity");
-    const retained = new Map();
-    let retainedBytes = 0;
-    const arms = manifest.arms.map(arm => {
-        const e = evidence.find(e => e.armId === arm.id);
-        let admitted = false;
-        const result = (state) => ({ armId: arm.id, state, eligible: state === "MEASURED", artifactDigests: admitted ? [...e.artifactDigests] : [], cost: admitted ? e.cost : null, costUnit: admitted ? e.costUnit : "unknown" });
-        if (!e)
-            return result("MISSING");
-        if (qualification.evidenceDigests[arm.id] !== interventionEvidenceDigest(e) || !closed(e, ["armId", "inputDigest", "artifactDigests", "cells", "cost", "costUnit"])
-            || e.inputDigest !== manifest.inputDigest || !Array.isArray(e.artifactDigests) || e.artifactDigests.length > 4096 || e.artifactDigests.some(h => !SHA.test(h))
-            || !(e.cost === null || (Number.isFinite(e.cost) && e.cost >= 0)) || e.costUnit !== manifest.resourceMetric || !Array.isArray(e.cells)
-            || new Set(e.artifactDigests).size !== e.artifactDigests.length || e.cells.length !== manifest.cases.reduce((n, c) => n + c.reps, 0))
-            return result("ERROR");
-        admitted = true;
-        const cells = new Map();
-        let error = false, unmeasured = false, unresolved = false, missingOutput = false;
-        for (const c of e.cells) {
-            const spec = manifest.cases.find(s => s.id === c.caseId), id = `${c.caseId}:${c.repetition}`;
-            if (!closed(c, ["caseId", "repetition", "delivery", "objective", "criteria", "suspect", "artifactSha256"]) || !spec || !Number.isSafeInteger(c.repetition) || c.repetition < 0 || c.repetition >= spec.reps || cells.has(id)
-                || !["PASS", "NOT-MEASURED", "ERROR"].includes(c.delivery) || !["PASS", "FAIL", "ERROR", "NOT-MEASURED"].includes(c.objective) || !Array.isArray(c.criteria) || typeof c.suspect !== "boolean") {
-                error = true;
-                continue;
-            }
-            cells.set(id, c);
-            if (c.artifactSha256 !== null && (typeof c.artifactSha256 !== "string" || !SHA.test(c.artifactSha256) || !e.artifactDigests.includes(c.artifactSha256)))
-                error = true;
-            if (c.delivery === "PASS" && c.objective === "PASS" && c.artifactSha256 === null)
-                missingOutput = true;
-            if (c.delivery !== "PASS" || c.objective !== "PASS") {
-                if (c.criteria.length)
-                    error = true;
-                if (c.delivery === "NOT-MEASURED")
-                    unmeasured = true;
-                if (c.delivery === "ERROR" || c.objective === "ERROR" || (c.objective === "NOT-MEASURED" && c.delivery !== "NOT-MEASURED"))
-                    error = true;
-            }
-            else if (c.criteria.length !== spec.criteria || c.criteria.some(v => !["PASS", "FAIL", "UNKNOWN"].includes(v)))
-                error = true;
-            else if (c.suspect || c.criteria.includes("UNKNOWN"))
-                unresolved = true;
-        }
-        if (error)
-            return result("ERROR");
-        if (unmeasured)
-            return result("NOT-MEASURED");
-        if (unresolved)
-            return result("UNRESOLVED");
-        if (missingOutput)
-            return result("MISSING");
-        const passed = manifest.cases.every(spec => Array.from(cells.values()).filter(c => c.caseId === spec.id && c.objective === "PASS" && c.criteria.every(v => v === "PASS")).length / spec.reps >= spec.threshold);
-        if (!passed)
-            return result("FAILED");
-        if (!e.artifactDigests.length)
-            return result("MISSING");
-        for (const hash of e.artifactDigests) {
-            const bytes = qualification.artifacts?.get(hash);
-            if (bytes === undefined)
-                return result("MISSING");
-            if (!(bytes instanceof Uint8Array) || bytes.byteLength > 8 * 1024 * 1024)
-                return result("ERROR");
-            const stable = Buffer.from(bytes);
-            if (createHash("sha256").update(stable).digest("hex") !== hash)
-                return result("ERROR");
-            if (!retained.has(hash)) {
-                if (retainedBytes + bytes.byteLength > 64 * 1024 * 1024)
-                    return result("ERROR");
-                retained.set(hash, stable);
-                retainedBytes += stable.byteLength;
-            }
-        }
-        return result("MEASURED");
-    });
-    const eligible = arms.filter(a => a.eligible), knownCosts = eligible.length && eligible.every(a => a.cost !== null && a.costUnit === eligible[0].costUnit);
-    const cheapestEligible = knownCosts ? [...eligible].sort((a, b) => a.cost - b.cost || (a.armId < b.armId ? -1 : 1))[0].armId : null;
-    const result = frozen({ manifestId: manifest.id, complete: arms.every(a => a.state === "MEASURED" || a.state === "FAILED"), arms, cheapestEligible, routingDefault: null, adoptionAuthorized: false });
-    assessments.add(result);
-    assessmentArtifacts.set(result, retained);
-    return result;
-}
-/** Only this view omits identity/cost; arbitrary artifact content can still leak clues and must be reviewed. */
-export function createBlindComparison(manifest, assessment, fixtureOrPersistedSeed) {
-    manifestValid(manifest);
-    if (!assessments.has(assessment) || assessment.manifestId !== manifest.id || !assessment.complete)
-        throw new Error("complete recomputed intervention assessment required");
-    const seed = fixtureOrPersistedSeed ?? randomBytes(32).toString("hex");
-    if (!SHA.test(seed))
-        throw new Error("invalid private blinding seed");
-    const assessmentId = digest(assessment);
-    const eligible = assessment.arms.filter(a => a.eligible).sort((a, b) => {
-        const left = digest([seed, manifest.id, assessmentId, a.armId]), right = digest([seed, manifest.id, assessmentId, b.armId]);
-        return left < right ? -1 : left > right ? 1 : 0;
-    });
-    const mapping = new Map(eligible.map((a, i) => [`variant-${digest([seed, manifest.id, assessmentId, i]).slice(0, 16)}`, a.armId]));
-    if (mapping.size !== eligible.length)
-        throw new Error("opaque label collision");
-    const cards = [...mapping].map(([label, armId]) => ({ label, artifactDigests: assessment.arms.find(a => a.armId === armId).artifactDigests }));
-    let choice = null, revealed = false;
-    return Object.freeze({
-        view: () => frozen({ version: "blind-intervention-view-v1", cards, limitations: ["artifact-content-may-disclose-identity"] }),
-        readArtifact(label, hash) {
-            const armId = mapping.get(label), arm = assessment.arms.find(a => a.armId === armId);
-            if (!arm || !arm.artifactDigests.includes(hash))
-                throw new Error("artifact outside blind view");
-            const bytes = assessmentArtifacts.get(assessment)?.get(hash);
-            if (!bytes)
-                throw new Error("retained blind artifact missing");
-            return Buffer.from(bytes);
-        },
-        choose(input) {
-            const value = clone(input);
-            if (!closed(value, ["kind", "labels"]) || !["one", "tie", "none", "insufficient"].includes(value.kind) || !Array.isArray(value.labels)
-                || new Set(value.labels).size !== value.labels.length || value.labels.some(l => !mapping.has(l))
-                || (value.kind === "one" ? value.labels.length !== 1 : value.kind === "tie" ? value.labels.length < 2 : value.labels.length !== 0))
-                throw new Error("invalid blind quality choice");
-            value.labels.sort();
-            if (revealed && canonical(choice) !== canonical(value))
-                throw new Error("quality choice locked after reveal");
-            choice = frozen(value);
-            return choice;
-        },
-        reveal() {
-            if (!choice)
-                throw new Error("quality choice required before reveal");
-            revealed = true;
-            return frozen({ manifestId: manifest.id, choice, arms: [...mapping].map(([label, armId]) => ({ label, armId, configuration: manifest.arms.find(a => a.id === armId).configuration,
-                    cost: assessment.arms.find(a => a.armId === armId).cost, costUnit: assessment.arms.find(a => a.armId === armId).costUnit })), routingDefault: null });
-        },
-    });
-}
-//# sourceMappingURL=intervention.js.map