@skill-harness/adapters 0.16.0 → 0.18.0

package/dist/intervention-run.d.ts

@@ -1,403 +0,0 @@
-import { type InterventionDraft, type InterventionQualification, type PanelVote } from '@skill-harness/core';
-type Role = {
-    requested: string;
-    canonical: string;
-};
-export interface InertModelCatalogueEntry extends Role {
-    efforts: string[];
-    lineage: string;
-}
-/** Exact retained/inert catalogue lookup; no provider calls, alias heuristics or fallback. */
-export declare function resolveInertRole(catalogue: InertModelCatalogueEntry[], requested: string, effort?: string): Role;
-export interface CastingScope {
-    station: string;
-    taskClass: string;
-    risk: string;
-    population: string;
-    version: string;
-}
-export interface InterventionRunInput {
-    kind: 'inert-retained-v1';
-    archiveRoot: string;
-    author: string;
-    catalogue: InertModelCatalogueEntry[];
-    scope: CastingScope;
-    draft: InterventionDraft;
-    roles: {
-        proposer: Role;
-        judges: Role[];
-        subjects: Record<string, Role & {
-            effort: string;
-        }>;
-    };
-    expected: Record<string, string[]>;
-}
-type Retained = {
-    configurationDigest: string;
-    delivery: 'PASS' | 'NOT-MEASURED' | 'ERROR';
-    outputBase64: string;
-    cost: number | null;
-};
-type Vote = Omit<PanelVote, 'ordinal'>;
-export type ProducerInterventionRunInput = Omit<InterventionRunInput, 'kind'> & {
-    kind: 'producer-ipc-v1';
-};
-export declare function validateProducerInterventionInput(raw: ProducerInterventionRunInput): {
-    input: InterventionRunInput | ProducerInterventionRunInput;
-    manifest: import("@skill-harness/core").InterventionManifest;
-    qualification: InterventionQualification;
-    cells: {
-        caseId: string;
-        repetition: number;
-        criteria: number;
-    }[];
-};
-export declare function createInterventionRun(path: string, raw: InterventionRunInput): {
-    configurations: () => {
-        armId: string;
-        requested: Record<import("@skill-harness/core").InterventionAxis, string>;
-        resolvedDeclaration: Role & {
-            effort: string;
-        };
-        inputDigest: string;
-        digest: string;
-        catalogueDigest: string;
-        lineage: string;
-        observedConfiguration: Record<string, unknown>[] | null;
-        qualification: string;
-    }[];
-    recordProducer(arm: string, index: number, hostPath: string, id: string): {
-        type: string;
-        arm: string;
-        index: number;
-        hostPath: string;
-        id: string;
-        planSha256: string;
-        configurationDigest: string;
-        serializedSha256: string;
-        requestSha256: unknown;
-        model: any;
-        effort: any;
-        instructionsSha256: string;
-        input: any;
-        outputSha256: unknown;
-        evidenceKind: string;
-        backendIdentity: null;
-        backendEffort: null;
-        instructionUse: null;
-        delivery: string;
-        settlementRef: string;
-    };
-    retain(arm: string, index: number, raw: Retained): void;
-    blind(): {
-        label: string;
-        index: number;
-        caseId: string;
-        outputBase64: string;
-        disclosure: string;
-    }[];
-    panel(arm: string, index: number, raw: Vote[][]): void;
-    finish(): {
-        assessment: import("@skill-harness/core").InterventionAssessment;
-        blindReviewId: string | null;
-        liveQualified: false;
-    };
-    casting(scope: CastingScope): {
-        qualityChoice: import("@skill-harness/core").BlindQualityChoice | null;
-        retainedCells: number;
-        requiredCells: number;
-        panels: (Record<string, unknown> | null)[];
-        cost: number | null;
-        costUnit: string;
-        latency: null;
-        measuredAcceptance: null;
-        escapes: null;
-        measuredSamples: number;
-        uncertainty: string;
-        revalidateOn: string[];
-        routingDefault: null;
-        liveQualified: boolean;
-        eligibleObserved?: boolean | undefined;
-        scope: CastingScope;
-        armId: string;
-        configuration: {
-            armId: string;
-            requested: Record<import("@skill-harness/core").InterventionAxis, string>;
-            resolvedDeclaration: Role & {
-                effort: string;
-            };
-            inputDigest: string;
-            digest: string;
-            catalogueDigest: string;
-            lineage: string;
-            observedConfiguration: Record<string, unknown>[] | null;
-            qualification: string;
-        };
-        conditionalState: "ERROR" | "NOT-MEASURED" | "MEASURED" | "FAILED" | "MISSING" | "UNRESOLVED";
-        eligibleInert: boolean;
-    }[];
-};
-export declare function createProducerInterventionRun(path: string, raw: ProducerInterventionRunInput, source: {
-    planSha256: string;
-    material: Record<string, {
-        skill: string;
-        prompt: string;
-        configuration: string;
-    }>;
-    cellIds: Record<string, string>;
-}): {
-    configurations: () => {
-        armId: string;
-        requested: Record<import("@skill-harness/core").InterventionAxis, string>;
-        resolvedDeclaration: Role & {
-            effort: string;
-        };
-        inputDigest: string;
-        digest: string;
-        catalogueDigest: string;
-        lineage: string;
-        observedConfiguration: Record<string, unknown>[] | null;
-        qualification: string;
-    }[];
-    recordProducer(arm: string, index: number, hostPath: string, id: string): {
-        type: string;
-        arm: string;
-        index: number;
-        hostPath: string;
-        id: string;
-        planSha256: string;
-        configurationDigest: string;
-        serializedSha256: string;
-        requestSha256: unknown;
-        model: any;
-        effort: any;
-        instructionsSha256: string;
-        input: any;
-        outputSha256: unknown;
-        evidenceKind: string;
-        backendIdentity: null;
-        backendEffort: null;
-        instructionUse: null;
-        delivery: string;
-        settlementRef: string;
-    };
-    retain(arm: string, index: number, raw: Retained): void;
-    blind(): {
-        label: string;
-        index: number;
-        caseId: string;
-        outputBase64: string;
-        disclosure: string;
-    }[];
-    panel(arm: string, index: number, raw: Vote[][]): void;
-    finish(): {
-        assessment: import("@skill-harness/core").InterventionAssessment;
-        blindReviewId: string | null;
-        liveQualified: false;
-    };
-    casting(scope: CastingScope): {
-        qualityChoice: import("@skill-harness/core").BlindQualityChoice | null;
-        retainedCells: number;
-        requiredCells: number;
-        panels: (Record<string, unknown> | null)[];
-        cost: number | null;
-        costUnit: string;
-        latency: null;
-        measuredAcceptance: null;
-        escapes: null;
-        measuredSamples: number;
-        uncertainty: string;
-        revalidateOn: string[];
-        routingDefault: null;
-        liveQualified: boolean;
-        eligibleObserved?: boolean | undefined;
-        scope: CastingScope;
-        armId: string;
-        configuration: {
-            armId: string;
-            requested: Record<import("@skill-harness/core").InterventionAxis, string>;
-            resolvedDeclaration: Role & {
-                effort: string;
-            };
-            inputDigest: string;
-            digest: string;
-            catalogueDigest: string;
-            lineage: string;
-            observedConfiguration: Record<string, unknown>[] | null;
-            qualification: string;
-        };
-        conditionalState: "ERROR" | "NOT-MEASURED" | "MEASURED" | "FAILED" | "MISSING" | "UNRESOLVED";
-        eligibleInert: boolean;
-    }[];
-};
-export declare function openInterventionRun(path: string): {
-    configurations: () => {
-        armId: string;
-        requested: Record<import("@skill-harness/core").InterventionAxis, string>;
-        resolvedDeclaration: Role & {
-            effort: string;
-        };
-        inputDigest: string;
-        digest: string;
-        catalogueDigest: string;
-        lineage: string;
-        observedConfiguration: Record<string, unknown>[] | null;
-        qualification: string;
-    }[];
-    recordProducer(arm: string, index: number, hostPath: string, id: string): {
-        type: string;
-        arm: string;
-        index: number;
-        hostPath: string;
-        id: string;
-        planSha256: string;
-        configurationDigest: string;
-        serializedSha256: string;
-        requestSha256: unknown;
-        model: any;
-        effort: any;
-        instructionsSha256: string;
-        input: any;
-        outputSha256: unknown;
-        evidenceKind: string;
-        backendIdentity: null;
-        backendEffort: null;
-        instructionUse: null;
-        delivery: string;
-        settlementRef: string;
-    };
-    retain(arm: string, index: number, raw: Retained): void;
-    blind(): {
-        label: string;
-        index: number;
-        caseId: string;
-        outputBase64: string;
-        disclosure: string;
-    }[];
-    panel(arm: string, index: number, raw: Vote[][]): void;
-    finish(): {
-        assessment: import("@skill-harness/core").InterventionAssessment;
-        blindReviewId: string | null;
-        liveQualified: false;
-    };
-    casting(scope: CastingScope): {
-        qualityChoice: import("@skill-harness/core").BlindQualityChoice | null;
-        retainedCells: number;
-        requiredCells: number;
-        panels: (Record<string, unknown> | null)[];
-        cost: number | null;
-        costUnit: string;
-        latency: null;
-        measuredAcceptance: null;
-        escapes: null;
-        measuredSamples: number;
-        uncertainty: string;
-        revalidateOn: string[];
-        routingDefault: null;
-        liveQualified: boolean;
-        eligibleObserved?: boolean | undefined;
-        scope: CastingScope;
-        armId: string;
-        configuration: {
-            armId: string;
-            requested: Record<import("@skill-harness/core").InterventionAxis, string>;
-            resolvedDeclaration: Role & {
-                effort: string;
-            };
-            inputDigest: string;
-            digest: string;
-            catalogueDigest: string;
-            lineage: string;
-            observedConfiguration: Record<string, unknown>[] | null;
-            qualification: string;
-        };
-        conditionalState: "ERROR" | "NOT-MEASURED" | "MEASURED" | "FAILED" | "MISSING" | "UNRESOLVED";
-        eligibleInert: boolean;
-    }[];
-};
-export declare function openProducerInterventionRun(path: string): {
-    configurations: () => {
-        armId: string;
-        requested: Record<import("@skill-harness/core").InterventionAxis, string>;
-        resolvedDeclaration: Role & {
-            effort: string;
-        };
-        inputDigest: string;
-        digest: string;
-        catalogueDigest: string;
-        lineage: string;
-        observedConfiguration: Record<string, unknown>[] | null;
-        qualification: string;
-    }[];
-    recordProducer(arm: string, index: number, hostPath: string, id: string): {
-        type: string;
-        arm: string;
-        index: number;
-        hostPath: string;
-        id: string;
-        planSha256: string;
-        configurationDigest: string;
-        serializedSha256: string;
-        requestSha256: unknown;
-        model: any;
-        effort: any;
-        instructionsSha256: string;
-        input: any;
-        outputSha256: unknown;
-        evidenceKind: string;
-        backendIdentity: null;
-        backendEffort: null;
-        instructionUse: null;
-        delivery: string;
-        settlementRef: string;
-    };
-    retain(arm: string, index: number, raw: Retained): void;
-    blind(): {
-        label: string;
-        index: number;
-        caseId: string;
-        outputBase64: string;
-        disclosure: string;
-    }[];
-    panel(arm: string, index: number, raw: Vote[][]): void;
-    finish(): {
-        assessment: import("@skill-harness/core").InterventionAssessment;
-        blindReviewId: string | null;
-        liveQualified: false;
-    };
-    casting(scope: CastingScope): {
-        qualityChoice: import("@skill-harness/core").BlindQualityChoice | null;
-        retainedCells: number;
-        requiredCells: number;
-        panels: (Record<string, unknown> | null)[];
-        cost: number | null;
-        costUnit: string;
-        latency: null;
-        measuredAcceptance: null;
-        escapes: null;
-        measuredSamples: number;
-        uncertainty: string;
-        revalidateOn: string[];
-        routingDefault: null;
-        liveQualified: boolean;
-        eligibleObserved?: boolean | undefined;
-        scope: CastingScope;
-        armId: string;
-        configuration: {
-            armId: string;
-            requested: Record<import("@skill-harness/core").InterventionAxis, string>;
-            resolvedDeclaration: Role & {
-                effort: string;
-            };
-            inputDigest: string;
-            digest: string;
-            catalogueDigest: string;
-            lineage: string;
-            observedConfiguration: Record<string, unknown>[] | null;
-            qualification: string;
-        };
-        conditionalState: "ERROR" | "NOT-MEASURED" | "MEASURED" | "FAILED" | "MISSING" | "UNRESOLVED";
-        eligibleInert: boolean;
-    }[];
-};
-export {};

package/dist/intervention-run.js

@@ -1,169 +0,0 @@
-import { createHash, randomBytes } from 'node:crypto';
-import { mkdirSync } from 'node:fs';
-import { freezeIntervention, assertInterventionRoles, assessIntervention, interventionEvidenceDigest, collapseVotePanel } from '@skill-harness/core';
-import { learningJournal, learningCopy, learningHash, registerLearningStore, verifyLearningStore } from './learning-journal.js';
-import { retainArchiveSource, readArchiveSource } from './evidence-archive.js';
-import { retainBlindIntervention, openBlindIntervention } from './blind-intervention.js';
-const sha = (b) => createHash('sha256').update(b).digest('hex');
-/** Exact retained/inert catalogue lookup; no provider calls, alias heuristics or fallback. */
-export function resolveInertRole(catalogue, requested, effort) {
-    catalogue = learningCopy(catalogue);
-    if (!Array.isArray(catalogue) || catalogue.length > 64 || catalogue.some(r => !r || [r.requested, r.canonical, r.lineage].some(s => typeof s !== 'string' || !s.length || s.length > 512) || !Array.isArray(r.efforts) || r.efforts.length > 16 || r.efforts.some(e => typeof e !== 'string' || !e.length || e.length > 128)) || new Set(catalogue.map(r => r.requested)).size !== catalogue.length)
-        throw Error('invalid inert role catalogue');
-    const match = catalogue.find(r => r.requested === requested);
-    if (!match || effort !== undefined && !match.efforts.includes(effort))
-        throw Error('unresolved role/effort; no fallback');
-    return { requested, canonical: match.canonical };
-}
-export function validateProducerInterventionInput(raw) { return admit(raw, true); }
-function admit(raw, producer = false) {
-    const input = learningCopy(raw);
-    if (input.kind !== (producer ? 'producer-ipc-v1' : 'inert-retained-v1'))
-        throw Error('only explicit inert retained or opt-in producer transport supported');
-    if (typeof input.author !== 'string' || !input.author.length || input.author.length > 512)
-        throw Error('explicit operator required');
-    const manifest = freezeIntervention(input.draft), roles = input.roles;
-    if (manifest.arms.length > 4 || manifest.cases.reduce((n, c) => n + c.reps, 0) > 64)
-        throw Error('bounded inert charter required');
-    if (!input.scope || Object.keys(input.scope).sort().join() !== 'population,risk,station,taskClass,version' || Object.values(input.scope).some(v => typeof v !== 'string' || !v.length || v.length > 512))
-        throw Error('closed casting scope required');
-    if (!roles || !Array.isArray(roles.judges) || roles.judges.length !== 3)
-        throw Error('three declared independent panel roles required');
-    const qualification = { manifestId: manifest.id, proposer: roles.proposer, judge: roles.judges[0], subjects: Object.fromEntries(Object.entries(roles.subjects).map(([id, r]) => [id, { requested: r.requested, canonical: r.canonical }])), evidenceDigests: {}, artifacts: new Map() };
-    assertInterventionRoles(manifest, qualification);
-    for (const r of [roles.proposer, ...roles.judges, ...Object.values(roles.subjects)]) {
-        const resolved = resolveInertRole(input.catalogue, r.requested, 'effort' in r ? String(r.effort) : undefined);
-        if (resolved.canonical !== r.canonical)
-            throw Error('role declaration differs from exact catalogue resolution');
-    }
-    const reserved = new Set([roles.proposer.canonical, ...roles.judges.map(j => j.canonical)]);
-    if (reserved.size !== 4 || roles.judges.some(j => [j.requested, j.canonical].some(s => typeof s !== 'string' || !s.length || s.length > 512 || /[\u0000-\u001f\u007f]/.test(s))) || manifest.arms.some(a => reserved.has(roles.subjects[a.id].canonical) || roles.subjects[a.id].effort !== a.configuration.effort))
-        throw Error('panel role conflict or unresolved effort');
-    const cells = manifest.cases.flatMap(c => Array.from({ length: c.reps }, (_, repetition) => ({ caseId: c.id, repetition, criteria: c.criteria })));
-    if (Object.keys(input.expected).sort().join() !== manifest.arms.map(a => a.id).sort().join() || manifest.arms.some(a => input.expected[a.id]?.length !== cells.length || input.expected[a.id].some(h => !/^[a-f0-9]{64}$/.test(h))))
-        throw Error('frozen objective hashes required for every cell');
-    return { input, manifest, qualification, cells };
-}
-export function createInterventionRun(path, raw) { return createRun(path, raw); }
-export function createProducerInterventionRun(path, raw, source) { return createRun(path, raw, learningCopy(source)); }
-function createRun(path, raw, source) {
-    const { input, manifest, cells } = admit(raw, !!source); // No archive, directory, output or panel effect before role admission.
-    if (source) {
-        const keys = manifest.arms.flatMap(a => cells.map((_, i) => `${a.id}:${i}`)).sort();
-        if (Object.keys(source).sort().join() !== 'cellIds,material,planSha256' || !/^[a-f0-9]{64}$/.test(source.planSha256) || Object.keys(source.cellIds).sort().join() !== keys.join() || new Set(Object.values(source.cellIds)).size !== keys.length || Object.values(source.cellIds).some(id => !/^[a-zA-Z0-9_-]{1,64}$/.test(id)) || Object.keys(source.material).sort().join() !== manifest.arms.map(a => a.id).sort().join() || manifest.arms.some(a => { const m = source.material[a.id]; return !m || Object.keys(m).sort().join() !== 'configuration,prompt,skill' || Object.values(m).some(v => typeof v !== 'string') || sha(m.skill) !== a.configuration.skill || sha(m.prompt) !== a.configuration.prompt || sha(m.configuration) !== a.configuration.configuration; }))
-            throw Error('frozen producer source binding required');
-    }
-    try {
-        mkdirSync(input.archiveRoot, { mode: 0o700 });
-    }
-    catch (e) {
-        if (e.code !== 'EEXIST')
-            throw e;
-    }
-    const binding = learningHash(source ? { input, source } : input);
-    registerLearningStore(input.archiveRoot, 'intervention', manifest.id, path, binding);
-    learningJournal(path, { type: source ? 'producer-intervention-run-v1' : 'intervention-run-v1', input, ...(source ? { source } : {}), seed: randomBytes(32).toString('hex') });
-    return openRun(path, !!source);
-}
-export function openInterventionRun(path) { return openRun(path); }
-export function openProducerInterventionRun(path) { return openRun(path, true); }
-function openRun(path, producer = false) {
-    const store = learningJournal(path), initial = store.read()[0].value;
-    if (initial.type !== (producer ? 'producer-intervention-run-v1' : 'intervention-run-v1') || typeof initial.seed !== 'string' || !/^[a-f0-9]{64}$/.test(initial.seed))
-        throw Error('invalid intervention owner');
-    const { input, manifest, qualification, cells } = admit(initial.input, producer);
-    const artifacts = new Map();
-    qualification.artifacts = artifacts;
-    const history = () => { verifyLearningStore(input.archiveRoot, 'intervention', manifest.id, path, learningHash(producer ? { input, source: initial.source } : input)); return store.read(); };
-    const append = (prior, value) => store.append(prior, value);
-    const configurations = () => manifest.arms.map(a => ({ armId: a.id, requested: learningCopy(a.configuration), resolvedDeclaration: learningCopy(input.roles.subjects[a.id]), inputDigest: manifest.inputDigest, digest: learningHash({ configuration: a.configuration, inputDigest: manifest.inputDigest }), catalogueDigest: learningHash(input.catalogue), lineage: input.catalogue.find(r => r.requested === a.configuration.model).lineage, observedConfiguration: producer ? history().filter(e => e.value.type === 'producer-configuration' && e.value.arm === a.id).map(e => e.value) : null, qualification: producer ? 'original-producer-sdk-observed; backend facts unknown' : 'inert-host-declaration-only' }));
-    const find = (type, arm, index) => history().find(e => e.value.type === type && e.value.arm === arm && e.value.index === index)?.value;
-    const check = (arm, index) => { if (!manifest.arms.some(a => a.id === arm) || !Number.isSafeInteger(index) || !cells[index])
-        throw Error('unfrozen arm/cell'); };
-    const label = (arm) => sha(String(initial.seed) + ':' + arm).slice(0, 24);
-    const bytes = (record) => { const read = readArchiveSource(input.archiveRoot, String(record.manifestId)); if (read.status !== 'available' || !read.bytes || sha(read.bytes) !== record.artifactSha256)
-        throw Error('retained arm artifact missing or changed'); return read.bytes; };
-    const api = { configurations,
-        recordProducer(arm, index, hostPath, id) {
-            if (!producer)
-                throw Error('producer observation requires opt-in owner');
-            check(arm, index);
-            if (find('producer-configuration', arm, index))
-                throw Error('configuration already observed');
-            const rows = learningJournal(hostPath).read(), values = rows.map(r => r.value), source = initial.source, cfg = manifest.arms.find(a => a.id === arm).configuration;
-            const observed = values.find(v => v.type === 'observation' && v.id === id), wire = values.find(v => v.type === 'sdk-wire-observed' && v.id === id), bound = values.find(v => v.type === 'producer-ipc-bound' && v.id === id), settled = values.find(v => v.type === 'producer-ipc-settled' && v.id === id);
-            if (source.cellIds[`${arm}:${index}`] !== id || !observed || !wire || !bound || !settled || bound.bindingHash !== settled.bindingHash || bound.binding.charterSha256 !== source.planSha256)
-                throw Error('original settled serializer evidence required');
-            const body = JSON.parse(Buffer.from(String(wire.serializedBase64), 'base64').toString('utf8')), instructions = source.material[arm].skill + '\n' + source.material[arm].prompt;
-            if (body.model !== cfg.model || body.reasoning?.effort !== cfg.effort || body.instructions !== instructions)
-                throw Error('actual serialized arm differs from frozen material');
-            const receipt = { type: 'producer-configuration', arm, index, hostPath, id, planSha256: source.planSha256, configurationDigest: configurations().find(c => c.armId === arm).digest, serializedSha256: sha(Buffer.from(String(wire.serializedBase64), 'base64')), requestSha256: wire.requestSha256, model: body.model, effort: body.reasoning.effort, instructionsSha256: sha(instructions), input: body.input, outputSha256: observed.outputSha256, evidenceKind: 'sdk-serialized-request', backendIdentity: null, backendEffort: null, instructionUse: null, delivery: 'PASS', settlementRef: rows.find(r => r.value === settled).id };
-            append(history().at(-1).id, receipt);
-            return receipt;
-        },
-        retain(arm, index, raw) {
-            check(arm, index);
-            const request = learningCopy(raw), records = history();
-            if (find('retained', arm, index) || find('retain-claimed', arm, index))
-                throw Error('arm cell already claimed; no automatic retry');
-            if (request.configurationDigest !== configurations().find(c => c.armId === arm).digest || !['PASS', 'NOT-MEASURED', 'ERROR'].includes(request.delivery) || !(request.cost === null || Number.isFinite(request.cost) && request.cost >= 0) || typeof request.outputBase64 !== 'string' || request.outputBase64.length > 87384)
-                throw Error('configuration/delivery/retained input mismatch');
-            const output = Buffer.from(request.outputBase64, 'base64');
-            if (output.toString('base64') !== request.outputBase64 || output.length > 65536)
-                throw Error('bounded canonical output required');
-            if (producer && request.delivery === 'PASS' && find('producer-configuration', arm, index)?.outputSha256 !== sha(output))
-                throw Error('retained output lacks original settled source');
-            const claim = append(records.at(-1).id, { type: 'retain-claimed', arm, index, requestDigest: learningHash(request) });
-            const source = retainArchiveSource(input.archiveRoot, { sourceId: `${producer ? 'producer' : 'inert'}-${manifest.id}-${arm}-${index}`, parser: { id: producer ? 'producer-variant-output' : 'inert-variant-output', version: '1' }, retention: 'exact', bytes: output });
-            append(claim.id, { type: 'retained', arm, index, manifestId: source.manifestId, artifactSha256: sha(output), configurationDigest: request.configurationDigest, delivery: request.delivery, objective: request.delivery === 'NOT-MEASURED' ? 'NOT-MEASURED' : request.delivery === 'ERROR' ? 'ERROR' : sha(output) === input.expected[arm][index] ? 'PASS' : 'FAIL', cost: request.cost });
-        },
-        blind() { return manifest.arms.flatMap(a => cells.flatMap((c, index) => { const r = find('retained', a.id, index); return r?.delivery === 'PASS' && r.objective === 'PASS' ? [{ label: label(a.id), index, caseId: c.caseId, outputBase64: Buffer.from(bytes(r)).toString('base64'), disclosure: producer ? 'artifact content may reveal identity; original source observations, not live blinding qualification' : 'artifact content may reveal identity; fixture transport, not live blinding qualification' }] : []; })).sort((a, b) => a.label.localeCompare(b.label) || a.index - b.index); },
-        panel(arm, index, raw) {
-            check(arm, index);
-            const records = history(), r = find('retained', arm, index);
-            if (!r || r.delivery !== 'PASS' || r.objective !== 'PASS')
-                throw Error('objective/delivery gate blocks panel');
-            bytes(r);
-            if (find('panel', arm, index))
-                throw Error('panel already recorded');
-            const votes = learningCopy(raw);
-            if (!Array.isArray(votes) || votes.length !== cells[index].criteria)
-                throw Error('criterion panel cardinality');
-            const panels = votes.map(row => { if (!Array.isArray(row) || ![2, 3].includes(row.length) || row.some(v => Object.keys(v).sort().join() !== 'suspect,verdict' || typeof v.suspect !== 'boolean' || !['PASS', 'FAIL', 'ERROR', 'NOT-MEASURED', 'JUDGE-AMBIGUOUS'].includes(v.verdict)))
-                throw Error('invalid retained votes'); const ranked = row.map((v, i) => ({ ...v, ordinal: i + 1 })); const split = collapseVotePanel(ranked.slice(0, 2)).split; if (split !== (row.length === 3))
-                throw Error('tie-break required exactly for clean split'); return { votes: ranked.map((v, i) => ({ ...v, role: input.roles.judges[i] })), collapse: collapseVotePanel(ranked) }; });
-            append(records.at(-1).id, { type: 'panel', arm, index, label: label(arm), panels });
-        },
-        finish() {
-            if (producer && (!history().some(e => e.value.type === 'producer-plan-settled') || history().some(e => e.value.type === 'producer-plan-failed')))
-                throw Error('whole producer plan unsettled');
-            const evidence = manifest.arms.flatMap(a => {
-                const retained = cells.map((_, i) => find('retained', a.id, i));
-                if (retained.some(r => !r))
-                    return [];
-                return [{ armId: a.id, inputDigest: manifest.inputDigest, artifactDigests: [...new Set(retained.map(r => String(r.artifactSha256)))], cost: retained.some(r => r.cost === null) ? null : retained.reduce((n, r) => n + Number(r.cost), 0), costUnit: manifest.resourceMetric, cells: retained.map((r, i) => { artifacts.set(String(r.artifactSha256), bytes(r)); const panel = find('panel', a.id, i); return { ...cells[i], criteria: r.objective === 'PASS' ? Array.from({ length: cells[i].criteria }, (_, k) => panel?.panels?.[k]?.collapse.verdict ?? 'UNKNOWN') : [], delivery: r.delivery, objective: r.objective, suspect: false, artifactSha256: String(r.artifactSha256) }; }) }];
-            });
-            qualification.evidenceDigests = Object.fromEntries(evidence.map(e => [e.armId, interventionEvidenceDigest(e)]));
-            const assessment = assessIntervention(manifest, evidence, qualification), records = history();
-            const old = records.find(e => e.value.type === 'finished');
-            if (old)
-                return learningCopy(old.value.result);
-            const result = { assessment, blindReviewId: null, liveQualified: false };
-            if (assessment.complete) {
-                if (records.some(e => e.value.type === 'finish-claimed'))
-                    throw Error('finish pending or unknown; no automatic retry');
-                const claim = append(records.at(-1).id, { type: 'finish-claimed' });
-                if (assessment.arms.some(a => a.eligible))
-                    result.blindReviewId = retainBlindIntervention(input.archiveRoot, manifest, evidence, qualification, input.author);
-                append(claim.id, { type: 'finished', result });
-            }
-            return result;
-        },
-        casting(scope) { if (learningHash(scope) !== learningHash(input.scope))
-            throw Error('casting scope/version requires revalidation'); const result = api.finish(); if (!result.blindReviewId)
-            throw Error('complete quality choice required before casting'); const blind = openBlindIntervention(input.archiveRoot, result.blindReviewId, input.author); if (!blind.quality())
-            throw Error('quality choice required before casting reveal'); blind.reveal(); return result.assessment.arms.map(arm => ({ scope: learningCopy(scope), armId: arm.armId, configuration: configurations().find(c => c.armId === arm.armId), conditionalState: arm.state, eligibleInert: !producer && arm.eligible, ...(producer ? { eligibleObserved: arm.eligible } : {}), qualityChoice: blind.quality(), retainedCells: cells.filter((_, i) => find('retained', arm.armId, i)).length, requiredCells: cells.length, panels: cells.map((_, i) => find('panel', arm.armId, i) ?? null), cost: arm.cost, costUnit: arm.costUnit, latency: null, measuredAcceptance: null, escapes: null, measuredSamples: 0, uncertainty: 'unqualified inert/retained protocol; panel agreement is not accuracy', revalidateOn: ['scope', 'model/effort/skill/prompt/configuration', 'rubric/judge policy', 'independent labels', 'delivery/effect transport'], routingDefault: null, liveQualified: false })); }
-    };
-    return api;
-}
-//# sourceMappingURL=intervention-run.js.map

package/dist/learning-case.d.ts

@@ -1,12 +0,0 @@
-export interface LearningCaseReference {
-    version: 2 | 3;
-    batchId: string;
-    manifestId: string;
-    decisionId: string;
-}
-/** Reads the actual selected-batch decision writer, not a caller-authored confirmation boolean. */
-export declare function readLearningCase(root: string, input: LearningCaseReference): {
-    candidate: import("@skill-harness/core").WorkCaptureCaseV2 | import("@skill-harness/core").WorkCaptureCaseV3;
-    current: import("@skill-harness/core").WorkCaseDecision | null;
-    matched: boolean;
-};

package/dist/learning-case.js

@@ -1,15 +0,0 @@
-import { createWorkCaseReviewer, createWorkSignalReviewer } from './work-case-review.js';
-import { readWorkCandidate } from './work-case-archive.js';
-import { readWorkSignalCase } from './work-signal-cases.js';
-import { learningCopy } from './learning-journal.js';
-/** Reads the actual selected-batch decision writer, not a caller-authored confirmation boolean. */
-export function readLearningCase(root, input) {
-    const c = learningCopy(input);
-    if (Object.keys(c).sort().join() !== 'batchId,decisionId,manifestId,version' || (c.version !== 2 && c.version !== 3))
-        throw Error('explicit selected case reference required');
-    const review = c.version === 3 ? createWorkSignalReviewer(root, c.batchId, 'learning-reader') : createWorkCaseReviewer(root, c.batchId, 'learning-reader');
-    const current = review.history(c.manifestId).at(-1) ?? null;
-    const candidate = c.version === 3 ? readWorkSignalCase(root, c.manifestId).candidate : readWorkCandidate(root, c.manifestId);
-    return { candidate, current, matched: current?.id === c.decisionId };
-}
-//# sourceMappingURL=learning-case.js.map

package/dist/learning-journal.d.ts

@@ -1,18 +0,0 @@
-export declare function learningJson(value: unknown): string;
-export declare const learningHash: (value: unknown) => string;
-export declare const learningCopy: <T>(value: T) => T;
-export interface LearningEvent {
-    id: string;
-    prior: string | null;
-    value: Record<string, unknown>;
-}
-export declare function learningFile(path: string, limit?: number): Buffer;
-/** Shared durable CAS for the weekly supervisor and trust lifecycle. Trusted cooperative filesystem,
- * not hostile same-UID rollback protection. A stranded claim is never automatically recovered. */
-export declare function learningJournal(path: string, initial?: Record<string, unknown>): {
-    read: () => LearningEvent[];
-    append(prior: string, value: Record<string, unknown>): LearningEvent;
-};
-/** One authoritative store per weekly key/policy in this archive; a renamed directory cannot refill it. */
-export declare function registerLearningStore(root: string, kind: 'weekly' | 'trust' | 'intervention' | 'access' | 'workspace', key: string, target: string, binding: string): void;
-export declare function verifyLearningStore(root: string, kind: 'weekly' | 'trust' | 'intervention' | 'access' | 'workspace', key: string, target: string, binding: string): void;