@skill-harness/core 0.11.0 → 0.13.0

package/dist/intervention.js

@@ -0,0 +1,218 @@
+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

package/dist/investigation.d.ts

@@ -0,0 +1,94 @@
+/** Bounded operator envelope; duplicate keys and over-expanded/cyclic objects are refused before dispatch. */
+export declare function parseLearningRequest(text: string): unknown;
+export interface HypothesisProposal {
+    archiveSnapshot: string;
+    caseIds: string[];
+    population: string;
+    intervention: string;
+    alternatives: string[];
+    prediction: string;
+    downside: string;
+    disproof: string;
+    rollback: string;
+    limits: {
+        subjectCalls: number;
+        judgeCalls: number;
+        wallMs: number;
+    };
+    effectProfile: string | null;
+}
+export interface Hypothesis {
+    version: "factory-hypothesis-v1";
+    id: string;
+    proposal: HypothesisProposal;
+    status: "proposed";
+}
+export declare function buildHypothesis(input: HypothesisProposal): Hypothesis;
+export interface InvestigationAuthority {
+    id: string;
+    investigations: readonly string[];
+    promotions: readonly string[];
+}
+/** Independent host declarations, not approval fields on a proposal and never adoption/activation authority. */
+export declare function authorizeInvestigation(h: Hypothesis, authority: InvestigationAuthority | null): {
+    version: string;
+    hypothesisId: string;
+    authorityId: string;
+    scope: "investigation-only";
+};
+export interface InvestigationScenarioPreview {
+    version: "investigation-scenario-preview-v1";
+    hypothesisId: string;
+    specPath: string;
+    baseSha256: string;
+    afterSha256: string;
+    scenario: Record<string, unknown>;
+    block: string;
+    digest: string;
+}
+export declare function previewInvestigationScenario(h: Hypothesis, specPath: string, scenario: Record<string, unknown>): InvestigationScenarioPreview;
+/** Exact preview consent includes destination, existing spec and complete scenario bytes. No automatic sanitization claim. */
+export declare function applyInvestigationScenario(h: Hypothesis, preview: InvestigationScenarioPreview, authority: InvestigationAuthority | null): {
+    scenarioId: string;
+    replayed: boolean;
+    sha256: string;
+    scope: "scenario-only";
+};
+export interface FrozenInvestigationInputs {
+    specSha256: string;
+    rubricSha256: string;
+    judgePolicySha256: string;
+    heldoutSha256: string;
+    configurationSha256: string;
+}
+export declare function freezeInvestigation(h: Hypothesis, inputs: FrozenInvestigationInputs, authority: InvestigationAuthority | null): {
+    digest: string;
+    version: string;
+    hypothesisId: string;
+    authorityId: string;
+    inputs: FrozenInvestigationInputs;
+    executionReady: false;
+};
+export declare function assertFrozenInvestigation(frozen: ReturnType<typeof freezeInvestigation>, current: FrozenInvestigationInputs): void;
+export interface WeeklyInvestigationInput {
+    week: string;
+    population: string;
+    policyDigest: string;
+    archiveSnapshot: string;
+    eligibleCaseIds: string[];
+    maxCases: number;
+}
+export interface WeeklyInvestigationSelection {
+    version: "weekly-investigation-selection-v1";
+    id: string;
+    key: string;
+    inputDigest: string;
+    week: string;
+    population: string;
+    policyDigest: string;
+    archiveSnapshot: string;
+    selectedCaseIds: string[];
+    sampling: "exploratory-sha256-order-v1";
+}
+/** The host persists these immutable selections; this function neither schedules a process nor spends tokens. */
+export declare function selectWeeklyInvestigation(history: readonly WeeklyInvestigationSelection[], input: WeeklyInvestigationInput): WeeklyInvestigationSelection;

package/dist/investigation.js

@@ -0,0 +1,148 @@
+import { createHash } from "node:crypto";
+import yaml from "js-yaml";
+import { readFileSync, realpathSync } from "node:fs";
+import { appendScenario, renderScenarioBlock, specSha256 } from "./spec-write.js";
+import { parseSpec } from "./spec.js";
+const SHA = /^[a-f0-9]{64}$/;
+const keys = (x, expected) => Object.keys(x).sort().join() === [...expected].sort().join();
+const text = (x, max = 4000) => typeof x === "string" && x.length > 0 && x.length <= max;
+function json(input) {
+    let nodes = 0;
+    const visit = (x, depth) => {
+        if (++nodes > 4096 || depth > 16)
+            throw new Error("investigation JSON exceeds bounds");
+        if (x === null || typeof x === "boolean" || typeof x === "string" || (typeof x === "number" && Number.isFinite(x)))
+            return x;
+        if (!x || typeof x !== "object" || (!Array.isArray(x) && ![Object.prototype, null].includes(Object.getPrototypeOf(x))))
+            throw new Error("plain investigation JSON required");
+        const descriptors = Object.getOwnPropertyDescriptors(x);
+        if (Array.isArray(x)) {
+            if (Object.getPrototypeOf(x) !== Array.prototype || x.length > 256 || Reflect.ownKeys(x).length !== x.length + 1)
+                throw new Error("bounded dense JSON array required");
+            return Array.from({ length: x.length }, (_, i) => { const d = descriptors[String(i)]; if (!d || !('value' in d))
+                throw new Error("plain JSON array required"); return visit(d.value, depth + 1); });
+        }
+        const out = {};
+        for (const key of Reflect.ownKeys(descriptors).sort((a, b) => String(a) < String(b) ? -1 : 1)) {
+            const d = descriptors[key];
+            if (typeof key !== "string" || !d.enumerable || !('value' in d))
+                throw new Error("plain JSON properties required");
+            Object.defineProperty(out, key, { value: visit(d.value, depth + 1), enumerable: true });
+        }
+        return out;
+    };
+    const result = visit(input, 0);
+    if (Buffer.byteLength(JSON.stringify(result)) > 65536)
+        throw new Error("investigation JSON exceeds byte bound");
+    return result;
+}
+/** Bounded operator envelope; duplicate keys and over-expanded/cyclic objects are refused before dispatch. */
+export function parseLearningRequest(text) {
+    if (typeof text !== "string" || Buffer.byteLength(text) > 65536)
+        throw new Error("learning request exceeds bound");
+    let value;
+    try {
+        value = yaml.load(text, { schema: yaml.JSON_SCHEMA, json: false });
+    }
+    catch {
+        throw new Error("invalid learning request");
+    }
+    return json(value);
+}
+const digest = (x) => createHash("sha256").update(JSON.stringify(json(x))).digest("hex");
+function freeze(value) { if (value && typeof value === "object") {
+    Object.values(value).forEach(freeze);
+    Object.freeze(value);
+} return value; }
+export function buildHypothesis(input) {
+    const p = json(input);
+    if (!keys(p, ["archiveSnapshot", "caseIds", "population", "intervention", "alternatives", "prediction", "downside", "disproof", "rollback", "limits", "effectProfile"])
+        || !SHA.test(p.archiveSnapshot) || !Array.isArray(p.caseIds) || !p.caseIds.length || p.caseIds.some(id => typeof id !== "string" || !SHA.test(id))
+        || ![p.population, p.intervention, p.prediction, p.downside, p.disproof, p.rollback].every(s => text(s))
+        || !Array.isArray(p.alternatives) || !p.alternatives.length || p.alternatives.some(a => !text(a))
+        || !p.limits || !keys(p.limits, ["subjectCalls", "judgeCalls", "wallMs"])
+        || !Object.values(p.limits).every(n => Number.isSafeInteger(n) && n >= 0 && n <= 1000000000)
+        || !(p.effectProfile === null || text(p.effectProfile, 512)))
+        throw new Error("invalid bounded hypothesis");
+    return freeze({ version: "factory-hypothesis-v1", id: digest({ version: "factory-hypothesis-v1", proposal: p }), proposal: p, status: "proposed" });
+}
+function authorize(h, authority) {
+    const value = json(h);
+    if (!keys(value, ["version", "id", "proposal", "status"]) || value.version !== "factory-hypothesis-v1" || value.status !== "proposed" || buildHypothesis(value.proposal).id !== value.id)
+        throw new Error("hypothesis identity changed");
+    if (!authority || !text(authority.id, 512) || !Array.isArray(authority.investigations) || !Array.isArray(authority.promotions)
+        || authority.investigations.length > 256 || authority.promotions.length > 256
+        || [...authority.investigations, ...authority.promotions].some(id => typeof id !== "string" || !SHA.test(id))
+        || !authority.investigations.includes(value.id))
+        throw new Error("independent investigation authority required");
+    return authority;
+}
+/** Independent host declarations, not approval fields on a proposal and never adoption/activation authority. */
+export function authorizeInvestigation(h, authority) {
+    const selected = authorize(h, authority);
+    return freeze({ version: "investigation-approval-v1", hypothesisId: h.id, authorityId: selected.id, scope: "investigation-only" });
+}
+export function previewInvestigationScenario(h, specPath, scenario) {
+    if (buildHypothesis(h.proposal).id !== h.id)
+        throw new Error("hypothesis identity changed");
+    const path = realpathSync(specPath), current = readFileSync(path, "utf8"), safe = json(scenario), block = renderScenarioBlock(safe);
+    parseSpec(current + block, path);
+    const value = { version: "investigation-scenario-preview-v1", hypothesisId: h.id, specPath: path, baseSha256: specSha256(current), afterSha256: specSha256(current + block), scenario: safe, block };
+    return freeze({ ...value, digest: digest(value) });
+}
+/** Exact preview consent includes destination, existing spec and complete scenario bytes. No automatic sanitization claim. */
+export function applyInvestigationScenario(h, preview, authority) {
+    const selected = authorize(h, authority), copy = json(preview), { digest: claimed, ...body } = copy;
+    if (!keys(copy, ["version", "hypothesisId", "specPath", "baseSha256", "afterSha256", "scenario", "block", "digest"])
+        || body.version !== "investigation-scenario-preview-v1" || body.hypothesisId !== h.id || digest(body) !== claimed
+        || renderScenarioBlock(body.scenario) !== body.block || !selected.promotions.includes(claimed))
+        throw new Error("exact privacy/promotion preview authority required");
+    if (realpathSync(body.specPath) !== body.specPath)
+        throw new Error("promotion destination changed");
+    const current = readFileSync(body.specPath, "utf8");
+    if (specSha256(current) === body.afterSha256)
+        return { scenarioId: String(body.scenario.id), replayed: true, sha256: body.afterSha256, scope: "scenario-only" };
+    const result = appendScenario({ specPath: body.specPath, scenario: body.scenario, baseSha256: body.baseSha256 });
+    return { scenarioId: result.id, replayed: false, sha256: result.sha256, scope: "scenario-only" };
+}
+function frozenInputs(input) {
+    const value = json(input);
+    if (!keys(value, ["specSha256", "rubricSha256", "judgePolicySha256", "heldoutSha256", "configurationSha256"]) || Object.values(value).some(v => typeof v !== "string" || !SHA.test(v)))
+        throw new Error("invalid frozen evaluation inputs");
+    return value;
+}
+export function freezeInvestigation(h, inputs, authority) {
+    const approved = authorizeInvestigation(h, authority), value = { version: "frozen-investigation-v1", hypothesisId: h.id, authorityId: approved.authorityId, inputs: frozenInputs(inputs), executionReady: false };
+    return freeze({ ...value, digest: digest(value) });
+}
+export function assertFrozenInvestigation(frozen, current) {
+    const { digest: recorded, ...value } = json(frozen);
+    if (!keys(value, ["version", "hypothesisId", "authorityId", "inputs", "executionReady"]) || !SHA.test(value.hypothesisId) || !text(value.authorityId, 512)
+        || value.version !== "frozen-investigation-v1" || value.executionReady !== false || digest(value) !== recorded || digest(value.inputs) !== digest(frozenInputs(current)))
+        throw new Error("frozen investigation changed or invalid");
+}
+/** The host persists these immutable selections; this function neither schedules a process nor spends tokens. */
+export function selectWeeklyInvestigation(history, input) {
+    const value = json(input);
+    if (!keys(value, ["week", "population", "policyDigest", "archiveSnapshot", "eligibleCaseIds", "maxCases"])
+        || !/^\d{4}-W(?:0[1-9]|[1-4]\d|5[0-3])$/.test(value.week) || !text(value.population, 512)
+        || !SHA.test(value.policyDigest) || !SHA.test(value.archiveSnapshot) || !Array.isArray(value.eligibleCaseIds)
+        || !value.eligibleCaseIds.length || value.eligibleCaseIds.some(id => typeof id !== "string" || !SHA.test(id))
+        || !Number.isSafeInteger(value.maxCases) || value.maxCases < 1 || value.maxCases > 32 || history.length > 4096)
+        throw new Error("invalid weekly investigation selection");
+    const eligible = [...new Set(value.eligibleCaseIds)].sort();
+    const key = digest({ week: value.week, population: value.population, policyDigest: value.policyDigest });
+    const inputDigest = digest({ ...value, eligibleCaseIds: eligible });
+    const selectedCaseIds = eligible.sort((a, b) => { const ka = digest([key, value.archiveSnapshot, a]), kb = digest([key, value.archiveSnapshot, b]); return ka < kb ? -1 : ka > kb ? 1 : 0; }).slice(0, value.maxCases);
+    const body = { version: "weekly-investigation-selection-v1", key, inputDigest, week: value.week, population: value.population,
+        policyDigest: value.policyDigest, archiveSnapshot: value.archiveSnapshot, selectedCaseIds, sampling: "exploratory-sha256-order-v1" };
+    const result = freeze({ ...body, id: digest(body) });
+    const previous = history.filter(record => record.key === key);
+    for (const record of previous) {
+        const { id, ...old } = json(record);
+        if (digest(old) !== id || id !== result.id)
+            throw new Error("weekly investigation already frozen or history invalid");
+    }
+    return previous.length ? freeze(json(previous[0])) : result;
+}
+//# sourceMappingURL=investigation.js.map

package/dist/journal.d.ts

@@ -103,7 +103,7 @@ export type JournalEvent = {
 }
 /**
  * A regate: needle gates re-evaluated against the saved staged diffs. `judge_calls`
- * is on the record because regate is advertised as free apart from the reps whose
+ * is on the record because regate may spend only on the reps whose
  * gate verdict flipped — a claim the journal should be able to settle. `skipped`
  * names scenarios it could not regate (vitest/post_test, or missing diff artifacts).
  */

package/dist/judge-agreement.d.ts

@@ -0,0 +1,19 @@
+import type { ResultsFile } from "./results.js";
+import type { Verdict } from "./score.js";
+export interface JudgeAgreementCell {
+    scenario: string;
+    status: "agree" | "disagree" | "error";
+    judges: string[];
+    verdicts: Verdict[];
+    detail: string;
+}
+export interface JudgeAgreementReport {
+    cells: JudgeAgreementCell[];
+    agree: number;
+    disagree: number;
+    error: number;
+    comparable: number;
+    rate: number | null;
+}
+/** Pure/offline projection of judgments already persisted in results.yaml. */
+export declare function judgeAgreement(results: ResultsFile): JudgeAgreementReport;

package/dist/judge-agreement.js

@@ -0,0 +1,31 @@
+/** Pure/offline projection of judgments already persisted in results.yaml. */
+export function judgeAgreement(results) {
+    const cells = results.scenarios.map((scenario) => {
+        const judgments = scenario.judge_history ?? scenario.adjudication?.judgments ?? [];
+        const distinct = new Map();
+        for (const judgment of judgments) {
+            const key = `${judgment.judge.provider}:${judgment.judge.model}`;
+            distinct.delete(key); // insertion order now reflects each judge's latest persisted vote
+            distinct.set(key, judgment);
+        }
+        const pair = [...distinct.entries()].slice(-2);
+        if (pair.length < 2 || pair.some(([, judgment]) => judgment.suspect || judgment.verdict === "ERROR" || judgment.verdict === "NOT-MEASURED" || judgment.verdict === "JUDGE-AMBIGUOUS")) {
+            return {
+                scenario: scenario.id, status: "error", judges: pair.map(([judge]) => judge),
+                verdicts: pair.map(([, judgment]) => judgment.verdict),
+                detail: pair.length < 2 ? "fewer than two distinct persisted judges" : "one or more judgments is not a clean vote",
+            };
+        }
+        const status = pair[0][1].verdict === pair[1][1].verdict ? "agree" : "disagree";
+        return {
+            scenario: scenario.id, status, judges: pair.map(([judge]) => judge),
+            verdicts: pair.map(([, judgment]) => judgment.verdict), detail: `${pair[0][1].verdict} vs ${pair[1][1].verdict}`,
+        };
+    });
+    const agree = cells.filter((cell) => cell.status === "agree").length;
+    const disagree = cells.filter((cell) => cell.status === "disagree").length;
+    const error = cells.filter((cell) => cell.status === "error").length;
+    const comparable = agree + disagree;
+    return { cells, agree, disagree, error, comparable, rate: comparable ? agree / comparable : null };
+}
+//# sourceMappingURL=judge-agreement.js.map

package/dist/judge-policy.js

@@ -4,15 +4,17 @@ import { BAKED_DEFAULT_JUDGE } from "./defaults.js";
  * Judge providers that cannot bill a per-token API.
  *
  * `claude-code` shells out to the `claude` CLI, authenticated with the user's
- * Claude subscription (OAuth). `ollama`/`lmstudio`/`llamacpp`/`local` are local
- * runtimes. Everything else is assumed to charge.
+ * Claude subscription (OAuth). `openai-codex` stays in Pi and authenticates with
+ * the user's ChatGPT subscription (OAuth). `ollama`/`lmstudio`/`llamacpp`/`local`
+ * are local runtimes. Everything else — including direct `openai` — is assumed
+ * to charge.
  *
  * An **allow-list**, deliberately, not a deny-list of known-paid providers: a
  * provider nobody has classified yet should be treated as able to bill, because
  * being wrong in that direction produces a surprise invoice while being wrong in
  * this direction produces one extra flag.
  */
-const FREE_JUDGE_PROVIDERS = new Set(["claude-code", "ollama", "lmstudio", "llamacpp", "local"]);
+const FREE_JUDGE_PROVIDERS = new Set(["claude-code", "openai-codex", "ollama", "lmstudio", "llamacpp", "local"]);
 /** Whether judging with this ref can charge a per-token API. */
 export function isMeteredJudge(judge) {
     return !FREE_JUDGE_PROVIDERS.has(judge.provider);

package/dist/lift.js

@@ -29,7 +29,7 @@ function conclusive(verdict, suspect) {
     // misfire are judge failures. Treating any of them as a FAIL would make
     // "red FAIL -> green PASS" fire on infrastructure noise, and lift would
     // measure flakiness while looking like skill value.
-    return !suspect && verdict !== "ERROR" && verdict !== "JUDGE-AMBIGUOUS";
+    return !suspect && verdict !== "ERROR" && verdict !== "NOT-MEASURED" && verdict !== "JUDGE-AMBIGUOUS";
 }
 function classify(red, green) {
     if (!conclusive(red.verdict, red.suspect) || !conclusive(green.verdict, green.suspect))

package/dist/lint.js

@@ -279,7 +279,7 @@ export function lintSkill(skillDir) {
                 else if (current !== recorded) {
                     // The remedy is per key kind, and it is the whole point of the split: a
                     // rubric edit is re-gradeable from saved transcripts, a policy edit is a
-                    // free rescore, a needle edit is a free regate. Only stimulus drift costs
+                    // free rescore, while a gate edit avoids a subject re-run via regate. Only stimulus drift costs
                     // model spend. One message saying "re-run" for all four is what made
                     // correcting a known-bad rubric expensive enough to skip.
                     findings.push({ skill, scenario, code: "stale", message: `${what} changed since the newest ${basename(tagDir)} run (${newest}) — results are stale; ${remedyForKey(key)}` });

package/dist/prompt-normalization.d.ts

@@ -0,0 +1,6 @@
+export declare const PROMPT_NORMALIZATION_RULE: "cwd-line-v1";
+export declare const PROMPT_NORMALIZATION_PATTERN = "^(Current working directory:)[^\\r\\n]*(\\r?)$";
+export declare const PROMPT_NORMALIZATION_FLAGS = "gm";
+export declare const PROMPT_NORMALIZATION_REPLACEMENT = "$1<normalized>$2";
+export declare const PROMPT_NORMALIZATION_SOURCE_KEY = "observation:prompt-normalization";
+export declare const PROMPT_NORMALIZATION_SOURCE_DIGEST: string;

package/dist/prompt-normalization.js

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+export const PROMPT_NORMALIZATION_RULE = "cwd-line-v1";
+export const PROMPT_NORMALIZATION_PATTERN = "^(Current working directory:)[^\\r\\n]*(\\r?)$";
+export const PROMPT_NORMALIZATION_FLAGS = "gm";
+export const PROMPT_NORMALIZATION_REPLACEMENT = "$1<normalized>$2";
+export const PROMPT_NORMALIZATION_SOURCE_KEY = "observation:prompt-normalization";
+export const PROMPT_NORMALIZATION_SOURCE_DIGEST = createHash("sha256").update(JSON.stringify([
+    "prompt-normalization-registry",
+    PROMPT_NORMALIZATION_RULE,
+    PROMPT_NORMALIZATION_PATTERN,
+    PROMPT_NORMALIZATION_FLAGS,
+    PROMPT_NORMALIZATION_REPLACEMENT,
+])).digest("hex");
+//# sourceMappingURL=prompt-normalization.js.map

package/dist/qualification-capture.d.ts

@@ -0,0 +1,44 @@
+export interface QualificationOutputReceipt {
+    path: string;
+    total_bytes: number;
+    captured_bytes: number;
+    truncated: boolean;
+    sha256: string;
+}
+export interface QualificationBoundedCapture {
+    path: string;
+    total_bytes: number;
+    captured_bytes: number;
+    truncated: boolean;
+    write(chunk: Buffer): void;
+    close(): void;
+}
+export interface QualificationArtifactAttestation {
+    ok: boolean;
+    actual: {
+        provider: string;
+        model: string;
+    } | null;
+    fallback: boolean;
+    refused: boolean;
+    error: string | null;
+}
+export declare function redactQualificationOutput(text: string, secretValues?: readonly string[]): string;
+export declare function openQualificationBoundedCapture(path: string, limit: number, redact: (text: string) => string): QualificationBoundedCapture;
+export declare function qualificationOutputReceipt(spoolRoot: string, path: string, capture: QualificationBoundedCapture): QualificationOutputReceipt;
+export declare function verifyQualificationOutputReceipt(spoolRoot: string, receipt: QualificationOutputReceipt): void;
+export declare function attestQualificationPiJsonl(text: string, requested: {
+    provider: string;
+    model: string;
+}): QualificationArtifactAttestation;
+export declare function spawnQualificationCapture(command: string, argv: string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    timeout_ms: number;
+    output_limit_bytes: number;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+    code: number | null;
+    timed_out: boolean;
+}>;