@skill-harness/adapters 0.17.0 → 0.18.0

package/dist/session-retention.js

@@ -1,121 +0,0 @@
-import { createHash } from 'node:crypto';
-import { resolve } from 'node:path';
-import { learningFile, learningHash, learningCopy } from './learning-journal.js';
-import { retainArchiveSource, readArchiveSource } from './evidence-archive.js';
-import { observePiSession, observeSessionLedger, sessionText } from './session-observation.js';
-const captured = new WeakMap();
-const sha = (bytes) => createHash('sha256').update(bytes).digest('hex');
-function checkedSelections(input) {
-    if (!Array.isArray(input) || input.length < 1 || input.length > 16)
-        throw Error('select 1–16 explicit session sources');
-    const seen = new Set(), executions = new Set();
-    let parents = 0, ledgers = 0;
-    for (const s of input) {
-        if (!s || typeof s !== 'object' || Object.keys(s).some(k => !['kind', 'path', 'executionId'].includes(k)))
-            throw Error('closed source selection required');
-        if (!['parent', 'child', 'ledger', 'feedback', 'artifact'].includes(s.kind) || typeof s.path !== 'string' || resolve(s.path) !== s.path)
-            throw Error('explicit absolute source path required');
-        if (seen.has(s.path))
-            throw Error('duplicate session source');
-        seen.add(s.path);
-        if (s.kind === 'parent')
-            parents++;
-        if (s.kind === 'ledger')
-            ledgers++;
-        if (s.executionId !== undefined) {
-            if (s.kind !== 'child' || !/^exec:[0-9a-f-]{36}$/i.test(s.executionId) || executions.has(s.executionId))
-                throw Error('unique child execution id required');
-            executions.add(s.executionId);
-        }
-    }
-    if (parents !== 1 || ledgers > 1)
-        throw Error('exactly one parent and at most one ledger required');
-}
-function projectSession(selections, buffers) {
-    const parent = observePiSession(buffers[selections.findIndex(s => s.kind === 'parent')]);
-    const children = selections.flatMap((s, i) => s.kind === 'child' ? [{ source: i, executionId: s.executionId ?? null, session: observePiSession(buffers[i]) }] : []);
-    if (new Set([parent.sessionId, ...children.map(c => c.session.sessionId)]).size !== children.length + 1)
-        throw Error('duplicate parent/child session id');
-    const ledger = selections.findIndex(s => s.kind === 'ledger'), attempts = ledger < 0 ? [] : observeSessionLedger(buffers[ledger]);
-    for (const child of children)
-        if (child.executionId && !attempts.some(a => a.executionId === child.executionId))
-            throw Error('selected child execution absent from ledger');
-    const gaps = [...parent.gaps, 'No quality, acceptance, calibrated learning or adoption is inferred from this import.'];
-    for (const child of children)
-        gaps.push(...child.session.gaps.map(g => 'Child source ' + (child.source + 1) + ' (' + child.session.sessionId + '): ' + g));
-    if (ledger < 0)
-        gaps.push('No delegation ledger selected.');
-    else
-        gaps.push('Ledger/session association is operator-selected, not authenticated; ledger may include other sessions.');
-    if (attempts.length > children.filter(c => c.executionId).length)
-        gaps.push('Child transcript coverage incomplete; no combined token total is claimed.');
-    if (children.length)
-        gaps.push('Child execution mappings are explicit operator declarations, not proof of parentage. Each transcript has separate usage.');
-    if (!selections.some(s => s.kind === 'feedback'))
-        gaps.push('External feedback not supplied; user messages remain available for review.');
-    if (!selections.some(s => s.kind === 'artifact'))
-        gaps.push('No final artifact or source snapshot supplied.');
-    return { parent, children, attempts, gaps };
-}
-/** Explicit local selection only. Does not scan session directories, follow links, or contact workers. */
-export function prepareSessionImport(selections) {
-    checkedSelections(selections);
-    const buffers = selections.map(s => learningFile(s.path, 8 * 1024 * 1024));
-    if (buffers.reduce((n, b) => n + b.length, 0) > 32 * 1024 * 1024)
-        throw Error('session selection exceeds 32 MiB');
-    const sources = selections.map((s, i) => ({ ...s, executionId: s.executionId ?? null, sha256: sha(buffers[i]), bytes: buffers[i].length }));
-    const { parent, children, attempts, gaps } = projectSession(selections, buffers);
-    const digest = learningHash({ version: 'session-selection-v1', sources });
-    const preview = { version: 'session-import-preview-v1', digest, sources, parent, children, attempts, gaps, acceptance: 'not-assessed' };
-    captured.set(preview, { preview: learningCopy(preview), buffers });
-    return preview;
-}
-export function retainSessionImport(root, preview, expectedDigest) {
-    const c = captured.get(preview);
-    if (!c || learningHash(c.preview) !== learningHash(preview) || expectedDigest !== c.preview.digest)
-        throw Error('exact preview digest required; changed or forged session import');
-    for (const s of c.preview.sources)
-        if (sha(learningFile(s.path, 8 * 1024 * 1024)) !== s.sha256)
-            throw Error('session source changed since preview; prepare again');
-    const sources = c.preview.sources.map((s, i) => {
-        const parser = s.kind === 'parent' || s.kind === 'child' ? 'pi-session-jsonl' : s.kind === 'ledger' ? 'pi-daddy-session-ledger' : 'session-evidence';
-        const r = retainArchiveSource(root, { sourceId: 'session-' + s.sha256, parser: { id: parser, version: '1' }, retention: 'exact', bytes: c.buffers[i] });
-        return { ...s, manifestId: r.manifestId };
-    });
-    const record = { version: 'retrospective-session-v1', selectionDigest: preview.digest, sources };
-    return retainArchiveSource(root, { sourceId: 'retrospective-' + preview.digest, parser: { id: 'retrospective-session', version: '1' }, retention: 'exact', bytes: Buffer.from(JSON.stringify(record)) }).manifestId;
-}
-export function readRetainedSession(root, manifestId) {
-    const selected = readArchiveSource(root, manifestId);
-    if (selected.status !== 'available' || selected.reference.retention !== 'exact' || selected.reference.parser.id !== 'retrospective-session' || selected.reference.parser.version !== '1')
-        throw Error('retained session unavailable or unsupported');
-    const record = JSON.parse(sessionText(selected.bytes));
-    if (!record || record.version !== 'retrospective-session-v1' || Object.keys(record).sort().join() !== 'selectionDigest,sources,version' || !Array.isArray(record.sources))
-        throw Error('invalid retained session');
-    checkedSelections(record.sources.map(s => ({ kind: s.kind, path: s.path, ...(s.executionId === null ? {} : { executionId: s.executionId }) })));
-    const sources = record.sources.map(s => {
-        if (Object.keys(s).sort().join() !== 'bytes,executionId,kind,manifestId,path,sha256')
-            throw Error('invalid retained session source');
-        const r = readArchiveSource(root, s.manifestId);
-        if (r.status !== 'available' || r.reference.retention !== 'exact' || r.reference.sha256 !== s.sha256 || r.bytes.length !== s.bytes)
-            throw Error('retained session source missing or changed');
-        return { selection: s, bytes: r.bytes };
-    });
-    if (sources.reduce((n, s) => n + s.bytes.length, 0) > 32 * 1024 * 1024)
-        throw Error('session selection exceeds 32 MiB');
-    const plain = record.sources.map(({ manifestId, ...s }) => s);
-    if (learningHash({ version: 'session-selection-v1', sources: plain }) !== record.selectionDigest)
-        throw Error('retained session selection mismatch');
-    const projection = projectSession(record.sources.map(s => ({ kind: s.kind, path: s.path, ...(s.executionId === null ? {} : { executionId: s.executionId }) })), sources.map(s => s.bytes));
-    return { version: record.version, manifestId, selectionDigest: record.selectionDigest, sources: record.sources, ...projection, acceptance: 'not-assessed' };
-}
-export function readRetainedSessionSource(root, manifestId, index) {
-    const session = readRetainedSession(root, manifestId), source = session.sources[index];
-    if (!Number.isSafeInteger(index) || !source)
-        throw Error('select a listed session source');
-    const result = readArchiveSource(root, source.manifestId);
-    if (result.status !== 'available')
-        throw Error('session source unavailable');
-    return result.bytes;
-}
-//# sourceMappingURL=session-retention.js.map

package/dist/trust-lifecycle.d.ts

@@ -1,152 +0,0 @@
-import { type CalibrationComponent, type CalibrationPrediction, type ExposurePolicy } from '@skill-harness/core';
-import { type LearningCaseReference } from './learning-case.js';
-export interface TrustLifecycleInput {
-    archiveRoot: string;
-    component: CalibrationComponent;
-    seed: string;
-    maxUnflagged: number;
-    cohort: {
-        incidentId: string;
-        manifestId: string;
-        flagged: boolean;
-        split: 'calibration' | 'heldout' | 'tuning';
-    }[];
-    exposure: ExposurePolicy | null;
-}
-export interface TrustReferenceOutcome {
-    kind: 'prediction' | 'unflagged';
-    targetId: string;
-    value: boolean;
-    evidenceManifestId: string;
-    referenceId: string;
-}
-export declare const trustPolicyDigest: (input: TrustLifecycleInput) => string;
-export declare const trustOutcomeDigest: (outcome: TrustReferenceOutcome) => string;
-export declare function createTrustLifecycle(directory: string, input: TrustLifecycleInput, authorizedPolicyDigests: readonly string[]): {
-    inspect: (now: number) => {
-        policyId: string;
-        component: CalibrationComponent;
-        calibration: {
-            version: "factory-calibration-v1";
-            reports: import("@skill-harness/core").CalibrationReport[];
-            excludedTuning: number;
-            referenceBasis: "independently-supplied-host-context";
-            advisoryOnly: true;
-        };
-        sampledIncidentIds: string[];
-        unflagged: {
-            sampled: number;
-            resolved: number;
-            misses: number;
-            unresolved: number;
-            conflicted: number;
-        };
-        attentionUsed: number;
-        retired: boolean;
-        exposures: {
-            mode: "ask" | "silent" | "retire";
-            reason: string;
-            id: string;
-        }[];
-        tip: string;
-        grantExpansion: false;
-    };
-    configuration: () => TrustLifecycleInput;
-    previewExposure: (now: number) => {
-        mode: "silent" | "ask" | "retire";
-        reason: string;
-        advisoryOnly: true;
-    } | {
-        mode: "retire";
-        reason: string;
-    } | {
-        mode: "silent";
-        reason: string;
-    };
-    history: () => import("./learning-journal.js").LearningEvent[];
-    previewCaseOutcome: (predictionId: string, reference: LearningCaseReference) => {
-        outcome: TrustReferenceOutcome;
-        caseReference: LearningCaseReference;
-        digest: string;
-        tip: string;
-    };
-    linkCaseOutcome(predictionId: string, reference: LearningCaseReference, authorizedDigests: readonly string[], referenceAuthor?: string): void;
-    predict(p: CalibrationPrediction): void;
-    correct(prior: string, p: CalibrationPrediction, reason: string): void;
-    outcome(value: TrustReferenceOutcome, authorizedReferenceDigests: readonly string[], referenceAuthor?: string): void;
-    expose(id: string, now: number): {
-        replayed: boolean;
-        mode: "ask" | "silent" | "retire";
-        reason: string;
-    } | {
-        replayed: boolean;
-        mode: "silent" | "ask" | "retire";
-        reason: string;
-        advisoryOnly: true;
-    };
-};
-/** Existing calibration is recomputed from durable scoped predictions and independently permitted
- * retained labels. Applied exposure is an attention reservation, not proof a human saw a question. */
-export declare function openTrustLifecycle(directory: string): {
-    inspect: (now: number) => {
-        policyId: string;
-        component: CalibrationComponent;
-        calibration: {
-            version: "factory-calibration-v1";
-            reports: import("@skill-harness/core").CalibrationReport[];
-            excludedTuning: number;
-            referenceBasis: "independently-supplied-host-context";
-            advisoryOnly: true;
-        };
-        sampledIncidentIds: string[];
-        unflagged: {
-            sampled: number;
-            resolved: number;
-            misses: number;
-            unresolved: number;
-            conflicted: number;
-        };
-        attentionUsed: number;
-        retired: boolean;
-        exposures: {
-            mode: "ask" | "silent" | "retire";
-            reason: string;
-            id: string;
-        }[];
-        tip: string;
-        grantExpansion: false;
-    };
-    configuration: () => TrustLifecycleInput;
-    previewExposure: (now: number) => {
-        mode: "silent" | "ask" | "retire";
-        reason: string;
-        advisoryOnly: true;
-    } | {
-        mode: "retire";
-        reason: string;
-    } | {
-        mode: "silent";
-        reason: string;
-    };
-    history: () => import("./learning-journal.js").LearningEvent[];
-    previewCaseOutcome: (predictionId: string, reference: LearningCaseReference) => {
-        outcome: TrustReferenceOutcome;
-        caseReference: LearningCaseReference;
-        digest: string;
-        tip: string;
-    };
-    linkCaseOutcome(predictionId: string, reference: LearningCaseReference, authorizedDigests: readonly string[], referenceAuthor?: string): void;
-    predict(p: CalibrationPrediction): void;
-    correct(prior: string, p: CalibrationPrediction, reason: string): void;
-    outcome(value: TrustReferenceOutcome, authorizedReferenceDigests: readonly string[], referenceAuthor?: string): void;
-    expose(id: string, now: number): {
-        replayed: boolean;
-        mode: "ask" | "silent" | "retire";
-        reason: string;
-    } | {
-        replayed: boolean;
-        mode: "silent" | "ask" | "retire";
-        reason: string;
-        advisoryOnly: true;
-    };
-};

package/dist/trust-lifecycle.js

@@ -1,209 +0,0 @@
-import { calibratePredictions, recommendExposure } from '@skill-harness/core';
-import { isAbsolute } from 'node:path';
-import { readArchiveSource } from './evidence-archive.js';
-import { learningCopy, learningHash, learningJournal, registerLearningStore, verifyLearningStore } from './learning-journal.js';
-import { readLearningCase } from './learning-case.js';
-export const trustPolicyDigest = (input) => learningHash({ version: 'trust-lifecycle-v1', input });
-export const trustOutcomeDigest = (outcome) => learningHash({ version: 'trust-reference-v1', outcome });
-function evidence(root, id) { const result = readArchiveSource(root, id); if (result.status !== 'available' || !['exact', 'redacted'].includes(result.reference.retention))
-    throw Error('independent retained evidence unavailable'); return result; }
-const text = (v) => typeof v === 'string' && v.length > 0 && v.length <= 512 && !/[\u0000-\u001f\u007f]/.test(v);
-function validate(input) {
-    if (!isAbsolute(input.archiveRoot) || Object.keys(input).sort().join() !== 'archiveRoot,cohort,component,exposure,maxUnflagged,seed' || !/^([a-f0-9]{64})$/.test(input.seed) || !Number.isSafeInteger(input.maxUnflagged) || input.maxUnflagged < 0 || input.maxUnflagged > 32 || !Array.isArray(input.cohort) || !input.cohort.length || input.cohort.length > 1024 || new Set(input.cohort.map(c => c.incidentId)).size !== input.cohort.length)
-        throw Error('invalid frozen trust cohort');
-    for (const c of input.cohort) {
-        if (Object.keys(c).sort().join() !== 'flagged,incidentId,manifestId,split' || !text(c.incidentId) || typeof c.flagged !== 'boolean' || !['calibration', 'heldout', 'tuning'].includes(c.split))
-            throw Error('invalid cohort row');
-        evidence(input.archiveRoot, c.manifestId);
-    }
-    const dummy = { id: 'validation', incidentId: 'validation', component: input.component, kind: input.component.kind === 'detector' ? 'positive' : 'approval', split: 'calibration' };
-    calibratePredictions([dummy]);
-    if (input.exposure) {
-        if (learningHash(input.exposure.component) !== learningHash(input.component))
-            throw Error('policy component scope mismatch');
-        const report = calibratePredictions([{ ...dummy, kind: input.exposure.kind, split: input.exposure.split }]).reports[0];
-        recommendExposure(report, input.exposure, 0);
-    }
-}
-export function createTrustLifecycle(directory, input, authorizedPolicyDigests) {
-    const safe = learningCopy(input);
-    validate(safe);
-    const policyId = trustPolicyDigest(safe);
-    if (!authorizedPolicyDigests.includes(policyId))
-        throw Error('independent predeclared policy authority required');
-    const sampledIncidentIds = safe.cohort.filter(c => !c.flagged && c.split !== 'tuning').sort((a, b) => learningHash([safe.seed, a.incidentId]).localeCompare(learningHash([safe.seed, b.incidentId]))).slice(0, safe.maxUnflagged).map(c => c.incidentId);
-    const initial = { type: 'initial', kind: 'trust-lifecycle-v1', input: safe, policyId, sampledIncidentIds };
-    registerLearningStore(safe.archiveRoot, 'trust', policyId, directory, learningHash(initial));
-    try {
-        learningJournal(directory, initial);
-    }
-    catch (e) {
-        if (e.code !== 'EEXIST')
-            throw e;
-        const old = learningJournal(directory).read()[0].value;
-        if (learningHash(old) !== learningHash(initial))
-            throw Error('trust policy already predeclared');
-    }
-    return openTrustLifecycle(directory);
-}
-/** Existing calibration is recomputed from durable scoped predictions and independently permitted
- * retained labels. Applied exposure is an attention reservation, not proof a human saw a question. */
-export function openTrustLifecycle(directory) {
-    const journal = learningJournal(directory), initial = journal.read()[0].value;
-    if (initial.kind !== 'trust-lifecycle-v1' || initial.type !== 'initial')
-        throw Error('wrong trust journal');
-    const input = initial.input, sampledIncidentIds = initial.sampledIncidentIds;
-    validate(input);
-    const replay = () => {
-        verifyLearningStore(input.archiveRoot, 'trust', String(initial.policyId), directory, learningHash(initial));
-        const history = journal.read(), predictions = new Map(), allIds = new Set(), outcomes = new Map(), caseLinks = new Map(), exposures = new Map();
-        let retired = false, lastExposureAt = 0;
-        for (const { value: v } of history.slice(1)) {
-            if (v.type === 'prediction' || v.type === 'correction') {
-                const p = v.prediction;
-                calibratePredictions([p]);
-                if (allIds.has(p.id))
-                    throw Error('duplicate prediction identity');
-                const c = input.cohort.find(c => c.incidentId === p.incidentId);
-                if (!c?.flagged || c.split !== p.split || learningHash(p.component) !== learningHash(input.component))
-                    throw Error('prediction scope mismatch');
-                if (v.type === 'correction') {
-                    const old = predictions.get(String(v.prior));
-                    if (!old || old.incidentId !== p.incidentId)
-                        throw Error('stale prediction correction');
-                    predictions.delete(String(v.prior));
-                }
-                predictions.set(p.id, p);
-                allIds.add(p.id);
-            }
-            else if (v.type === 'outcome') {
-                const r = v.outcome;
-                if (outcomes.has(r.referenceId))
-                    throw Error('duplicate reference identity');
-                outcomes.set(r.referenceId, r);
-                if (v.caseReference)
-                    caseLinks.set(r.referenceId, v.caseReference);
-            }
-            else if (v.type === 'exposure') {
-                const id = String(v.id), result = v.result;
-                if (typeof v.now !== 'number' || !Number.isFinite(v.now) || v.now < lastExposureAt || exposures.has(id) || !['ask', 'silent', 'retire'].includes(result.mode))
-                    throw Error('invalid exposure history');
-                lastExposureAt = v.now;
-                exposures.set(id, result);
-                retired ||= result.mode === 'retire';
-            }
-            else
-                throw Error('unknown trust history event');
-        }
-        return { history, predictions, allIds, outcomes, caseLinks, exposures, retired, lastExposureAt, tip: history.at(-1).id };
-    };
-    replay();
-    const inspect = (now) => {
-        if (!Number.isFinite(now) || now < 0)
-            throw Error('valid policy clock required');
-        const s = replay(), labels = [];
-        for (const r of s.outcomes.values()) {
-            evidence(input.archiveRoot, r.evidenceManifestId);
-            const p = s.predictions.get(r.targetId), link = s.caseLinks.get(r.referenceId);
-            if (link && !readLearningCase(input.archiveRoot, link).matched)
-                continue;
-            if (r.kind === 'prediction' && p)
-                labels.push({ ...p, id: r.referenceId, correct: r.value });
-        }
-        for (const p of s.predictions.values())
-            evidence(input.archiveRoot, input.cohort.find(c => c.incidentId === p.incidentId).manifestId);
-        const calibration = calibratePredictions([...s.predictions.values()], { outcomes: labels });
-        let misses = 0, resolved = 0, conflicted = 0;
-        for (const id of sampledIncidentIds) {
-            evidence(input.archiveRoot, input.cohort.find(c => c.incidentId === id).manifestId);
-            const values = new Set([...s.outcomes.values()].filter(r => r.kind === 'unflagged' && r.targetId === id).map(r => r.value));
-            if (values.size === 1) {
-                resolved++;
-                if (values.has(true))
-                    misses++;
-            }
-            else if (values.size > 1)
-                conflicted++;
-        }
-        return { policyId: String(initial.policyId), component: learningCopy(input.component), calibration, sampledIncidentIds: [...sampledIncidentIds], unflagged: { sampled: sampledIncidentIds.length, resolved, misses, unresolved: sampledIncidentIds.length - resolved, conflicted }, attentionUsed: [...s.exposures.values()].filter(e => e.mode === 'ask').length, retired: s.retired, exposures: [...s.exposures].map(([id, result]) => ({ id, ...result })), tip: s.tip, grantExpansion: false };
-    };
-    const prediction = (p) => { const copy = learningCopy(p); calibratePredictions([copy]); const row = input.cohort.find(c => c.incidentId === copy.incidentId); if (!row?.flagged || row.split !== copy.split || learningHash(copy.component) !== learningHash(input.component))
-        throw Error('prediction scope mismatch'); evidence(input.archiveRoot, row.manifestId); return copy; };
-    const previewCaseOutcome = (predictionId, reference) => {
-        const ref = learningCopy(reference), s = replay(), p = s.predictions.get(predictionId), row = p && input.cohort.find(c => c.incidentId === p.incidentId), resolved = readLearningCase(input.archiveRoot, ref);
-        if (!p || p.kind !== 'positive' || row?.manifestId !== ref.manifestId || !resolved.matched || !['confirmed_defect', 'expected_behavior'].includes(resolved.current.disposition) || learningHash(resolved.candidate.detector) !== learningHash({ id: p.component.id, version: p.component.version, population: p.component.population }))
-            throw Error('current independent case outcome scope required');
-        const outcome = { kind: 'prediction', targetId: p.id, value: resolved.current.disposition === 'confirmed_defect', evidenceManifestId: ref.manifestId, referenceId: ref.decisionId };
-        return { outcome, caseReference: ref, digest: learningHash({ outcome, caseReference: ref }), tip: s.tip };
-    };
-    const previewExposure = (now) => {
-        const view = inspect(now), policy = input.exposure ? { ...input.exposure, attentionRemaining: Math.max(0, input.exposure.attentionRemaining - view.attentionUsed) } : null;
-        const report = view.calibration.reports.find(r => policy && r.kind === policy.kind && r.split === policy.split);
-        return view.retired ? { mode: 'retire', reason: 'previously-retired' } : report ? recommendExposure(report, policy, now) : { mode: 'silent', reason: policy ? 'insufficient-independent-evidence' : 'policy-unavailable' };
-    };
-    return { inspect, configuration: () => learningCopy(input), previewExposure, history: () => journal.read(), previewCaseOutcome,
-        linkCaseOutcome(predictionId, reference, authorizedDigests, referenceAuthor) {
-            if (referenceAuthor !== undefined && !text(referenceAuthor))
-                throw Error('explicit reference author required');
-            const preview = previewCaseOutcome(predictionId, reference);
-            if (!authorizedDigests.includes(preview.digest))
-                throw Error('independent exact reference authority required');
-            const s = replay();
-            if (s.tip !== preview.tip)
-                throw Error('stale case outcome snapshot');
-            const old = s.outcomes.get(preview.outcome.referenceId);
-            if (old) {
-                if (trustOutcomeDigest(old) !== trustOutcomeDigest(preview.outcome) || learningHash(s.caseLinks.get(old.referenceId) ?? null) !== learningHash(reference))
-                    throw Error('reference identity conflict');
-                return;
-            }
-            journal.append(s.tip, { type: 'outcome', outcome: preview.outcome, caseReference: preview.caseReference, authorityDigest: preview.digest, ...(referenceAuthor === undefined ? {} : { referenceAuthor }) });
-        },
-        predict(p) { const safe = prediction(p), s = replay(); if (s.allIds.has(safe.id)) {
-            if (learningHash(s.predictions.get(safe.id) ?? null) !== learningHash(safe))
-                throw Error('prediction identity conflict');
-            return;
-        } journal.append(s.tip, { type: 'prediction', prediction: safe }); },
-        correct(prior, p, reason) { const safe = prediction(p), s = replay(), old = s.predictions.get(prior); if (!old || old.incidentId !== safe.incidentId || s.allIds.has(safe.id) || !text(reason))
-            throw Error('stale or invalid prediction correction'); journal.append(s.tip, { type: 'correction', prior, prediction: safe, reason }); },
-        outcome(value, authorizedReferenceDigests, referenceAuthor) {
-            if (referenceAuthor !== undefined && !text(referenceAuthor))
-                throw Error('explicit reference author required');
-            const r = learningCopy(value);
-            if (Object.keys(r).sort().join() !== 'evidenceManifestId,kind,referenceId,targetId,value' || !['prediction', 'unflagged'].includes(r.kind) || !text(r.targetId) || !text(r.referenceId) || typeof r.value !== 'boolean')
-                throw Error('invalid reference outcome');
-            const digest = trustOutcomeDigest(r);
-            if (!authorizedReferenceDigests.includes(digest))
-                throw Error('independent exact reference authority required');
-            evidence(input.archiveRoot, r.evidenceManifestId);
-            const s = replay();
-            if (r.kind === 'prediction' ? !s.predictions.has(r.targetId) : !sampledIncidentIds.includes(r.targetId))
-                throw Error('outcome outside current prediction or frozen sample');
-            const old = s.outcomes.get(r.referenceId);
-            if (old) {
-                if (trustOutcomeDigest(old) !== digest)
-                    throw Error('reference identity conflict');
-                return;
-            }
-            journal.append(s.tip, { type: 'outcome', outcome: r, authorityDigest: digest, ...(referenceAuthor === undefined ? {} : { referenceAuthor }) });
-        },
-        expose(id, now) {
-            if (!text(id))
-                throw Error('exposure identity required');
-            const s = replay(), existing = s.exposures.get(id);
-            if (existing)
-                return { ...learningCopy(existing), replayed: true };
-            if (now < s.lastExposureAt)
-                throw Error('policy clock moved backwards');
-            const view = inspect(now);
-            if (view.tip !== s.tip)
-                throw Error('stale exposure snapshot');
-            const policy = input.exposure ? { ...input.exposure, attentionRemaining: Math.max(0, input.exposure.attentionRemaining - view.attentionUsed) } : null;
-            const report = view.calibration.reports.find(r => policy && r.kind === policy.kind && r.split === policy.split);
-            const result = s.retired ? { mode: 'retire', reason: 'previously-retired' } : report ? recommendExposure(report, policy, now) : { mode: 'silent', reason: policy ? 'insufficient-independent-evidence' : 'policy-unavailable' };
-            journal.append(s.tip, { type: 'exposure', id, now, result, policyId: initial.policyId, evidenceTip: s.tip });
-            return { ...learningCopy(result), replayed: false };
-        }
-    };
-}
-//# sourceMappingURL=trust-lifecycle.js.map