@skill-harness/adapters 0.16.0 → 0.18.0

package/dist/prompt-provenance.d.ts

@@ -1,22 +0,0 @@
-import { PROMPT_NORMALIZATION_RULE, type PromptMechanism, type PromptProvenance } from "@skill-harness/core";
-export { PROMPT_NORMALIZATION_RULE } from "@skill-harness/core";
-/** Registry entry 1: replace exactly Pi's dynamic cwd line, preserving every other byte. */
-export declare function normalizePromptPayload(value: unknown, rule: typeof PROMPT_NORMALIZATION_RULE): unknown;
-export declare function promptCaptureIsTrusted(extensionCount: number, hasRuntimeInjection?: boolean): boolean;
-export interface AuthenticatedPromptObservation {
-    observation: PromptProvenance;
-    mac: string;
-}
-export interface AuthenticatedPromptSummary {
-    summary: {
-        count: number;
-    };
-    mac: string;
-}
-export declare function authenticatePromptObservation(observation: PromptProvenance, authenticationKey: string): AuthenticatedPromptObservation;
-export declare function authenticatePromptSummary(count: number, authenticationKey: string): AuthenticatedPromptSummary;
-export declare function verifyPromptSummary(value: unknown, expectedCount: number, authenticationKey: string): boolean;
-/** Compute observation from final provider payload prompt bytes; caller supplies content, never status. */
-export declare function observeProviderPayload(payload: unknown, contract: string, mechanism: PromptMechanism, requestIndex: number): PromptProvenance;
-/** Parent-side binding: never accept contract identity or status from the child observer. */
-export declare function bindPromptObservation(value: unknown, contract: string, mechanism: PromptMechanism, requestIndex: number, authenticationKey: string, observerRequestIndex?: number): PromptProvenance;

package/dist/prompt-provenance.js

@@ -1,146 +0,0 @@
-import { createHash, createHmac, timingSafeEqual } from "node:crypto";
-import { PROMPT_NORMALIZATION_FLAGS, PROMPT_NORMALIZATION_PATTERN, PROMPT_NORMALIZATION_REPLACEMENT, PROMPT_NORMALIZATION_RULE } from "@skill-harness/core";
-export { PROMPT_NORMALIZATION_RULE } from "@skill-harness/core";
-function sha(bytes) {
-    return createHash("sha256").update(bytes, "utf8").digest("hex");
-}
-/** Registry entry 1: replace exactly Pi's dynamic cwd line, preserving every other byte. */
-export function normalizePromptPayload(value, rule) {
-    if (rule !== PROMPT_NORMALIZATION_RULE)
-        throw new Error(`unknown prompt normalization rule ${String(rule)}`);
-    if (typeof value === "string")
-        return value.replace(new RegExp(PROMPT_NORMALIZATION_PATTERN, PROMPT_NORMALIZATION_FLAGS), PROMPT_NORMALIZATION_REPLACEMENT);
-    if (Array.isArray(value))
-        return value.map((entry) => normalizePromptPayload(entry, rule));
-    if (value && typeof value === "object")
-        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizePromptPayload(entry, rule)]));
-    return value;
-}
-function countInStrings(value, needle) {
-    if (typeof value === "string") {
-        if (!needle)
-            return 0;
-        let count = 0, at = 0;
-        while ((at = value.indexOf(needle, at)) !== -1) {
-            count++;
-            at += needle.length;
-        }
-        return count;
-    }
-    if (Array.isArray(value))
-        return value.reduce((sum, entry) => sum + countInStrings(entry, needle), 0);
-    if (value && typeof value === "object") {
-        const record = value;
-        // A scenario may quote the contract. User-authored text is stimulus, never
-        // delivery, but providers also place tool results inside role=user messages.
-        if (record.role === "user") {
-            const content = Array.isArray(record.content) ? record.content : Array.isArray(record.parts) ? record.parts : [];
-            return content
-                .filter(block => block && typeof block === "object" && (["tool_result", "tool_response", "function_response"].includes(String(block.type ?? "")) ||
-                "functionResponse" in block || "function_response" in block))
-                .reduce((sum, block) => sum + countInStrings(block, needle), 0);
-        }
-        return Object.values(record).reduce((sum, entry) => sum + countInStrings(entry, needle), 0);
-    }
-    return 0;
-}
-const PROMPT_FIELDS = new Set(["instructions", "input", "system", "messages", "prompt", "contents"]);
-function promptProjection(payload) {
-    if (!payload || typeof payload !== "object" || Array.isArray(payload))
-        return null;
-    const record = payload;
-    const projected = Object.fromEntries(Object.entries(record).filter(([key]) => PROMPT_FIELDS.has(key)));
-    const config = record.config && typeof record.config === "object" ? record.config : null;
-    if (config?.systemInstruction !== undefined)
-        projected.systemInstruction = config.systemInstruction;
-    return Object.keys(projected).length ? projected : null;
-}
-export function promptCaptureIsTrusted(extensionCount, hasRuntimeInjection = false) {
-    return extensionCount === 0 && !hasRuntimeInjection;
-}
-function observationMac(observation, authenticationKey) {
-    return createHmac("sha256", authenticationKey).update(JSON.stringify(observation)).digest("hex");
-}
-export function authenticatePromptObservation(observation, authenticationKey) {
-    return { observation, mac: observationMac(observation, authenticationKey) };
-}
-export function authenticatePromptSummary(count, authenticationKey) {
-    const summary = { count };
-    return { summary, mac: createHmac("sha256", authenticationKey).update(JSON.stringify(summary)).digest("hex") };
-}
-function validMac(supplied, expected) {
-    if (typeof supplied !== "string" || !/^[a-f0-9]{64}$/i.test(supplied))
-        return false;
-    const suppliedBytes = Buffer.from(supplied, "hex"), expectedBytes = Buffer.from(expected, "hex");
-    return suppliedBytes.length === expectedBytes.length && timingSafeEqual(suppliedBytes, expectedBytes);
-}
-export function verifyPromptSummary(value, expectedCount, authenticationKey) {
-    if (!value || typeof value !== "object")
-        return false;
-    const envelope = value;
-    if (!envelope.summary || envelope.summary.count !== expectedCount)
-        return false;
-    const expected = createHmac("sha256", authenticationKey).update(JSON.stringify(envelope.summary)).digest("hex");
-    return validMac(envelope.mac, expected);
-}
-function statusFor(occurrences, mechanism, observable) {
-    if (!observable)
-        return "ERROR";
-    return occurrences === (mechanism === "none" ? 0 : 1) ? "PASS" : "NOT-MEASURED";
-}
-/** Compute observation from final provider payload prompt bytes; caller supplies content, never status. */
-export function observeProviderPayload(payload, contract, mechanism, requestIndex) {
-    const projection = promptProjection(payload);
-    const raw = JSON.stringify(projection ?? {});
-    const normalized = JSON.stringify(normalizePromptPayload(projection ?? {}, PROMPT_NORMALIZATION_RULE));
-    const occurrences = countInStrings(projection ?? {}, contract);
-    const observable = projection !== null;
-    return {
-        capture_version: "prompt-provenance-v1",
-        request_index: requestIndex,
-        raw_sha256: sha(raw),
-        normalized_sha256: sha(normalized),
-        normalization_rule: PROMPT_NORMALIZATION_RULE,
-        bytes: Buffer.byteLength(raw),
-        contract_sha256: sha(contract),
-        contract_bytes: Buffer.byteLength(contract),
-        contract_occurrences: occurrences,
-        mechanism,
-        status: statusFor(occurrences, mechanism, observable),
-        ...(observable ? {} : { error: "provider payload has no supported model-visible prompt field" }),
-    };
-}
-/** Parent-side binding: never accept contract identity or status from the child observer. */
-export function bindPromptObservation(value, contract, mechanism, requestIndex, authenticationKey, observerRequestIndex = requestIndex) {
-    const fallback = { ...observeProviderPayload({}, contract, mechanism, requestIndex), status: "ERROR" };
-    if (!value || typeof value !== "object")
-        return { ...fallback, error: "prompt observer emitted a non-object record" };
-    const envelope = value;
-    if (!envelope.observation)
-        return { ...fallback, error: "prompt observation authentication missing" };
-    const expectedMac = observationMac(envelope.observation, authenticationKey);
-    if (!validMac(envelope.mac, expectedMac))
-        return { ...fallback, error: "prompt observation authentication failed" };
-    const record = envelope.observation;
-    if (record.request_index !== observerRequestIndex)
-        return { ...fallback, error: "prompt observation replay or ordering mismatch" };
-    const expectedDigest = sha(contract), expectedBytes = Buffer.byteLength(contract);
-    const valid = record.capture_version === "prompt-provenance-v1" &&
-        record.normalization_rule === PROMPT_NORMALIZATION_RULE && record.mechanism === mechanism &&
-        record.contract_sha256 === expectedDigest && record.contract_bytes === expectedBytes &&
-        typeof record.raw_sha256 === "string" && /^[a-f0-9]{64}$/i.test(record.raw_sha256) &&
-        typeof record.normalized_sha256 === "string" && /^[a-f0-9]{64}$/i.test(record.normalized_sha256) &&
-        Number.isInteger(record.bytes) && record.bytes >= 0 &&
-        Number.isInteger(record.contract_occurrences) && record.contract_occurrences >= 0;
-    if (!valid)
-        return { ...fallback, error: "prompt observation failed parent contract/provenance binding" };
-    const occurrences = record.contract_occurrences;
-    return {
-        capture_version: "prompt-provenance-v1", request_index: requestIndex,
-        raw_sha256: record.raw_sha256, normalized_sha256: record.normalized_sha256,
-        normalization_rule: PROMPT_NORMALIZATION_RULE, bytes: record.bytes,
-        contract_sha256: expectedDigest, contract_bytes: expectedBytes, contract_occurrences: occurrences,
-        mechanism, status: statusFor(occurrences, mechanism, true),
-    };
-}
-//# sourceMappingURL=prompt-provenance.js.map

package/dist/reviewed-archive-export.d.ts

@@ -1,42 +0,0 @@
-import { type GovernedArchiveRoute } from './archive-access.js';
-export interface ReviewedExportPolicy {
-    archiveRoot: string;
-    access?: GovernedArchiveRoute;
-    manifestIds: string[];
-    destination: string;
-    expiresAt: number;
-    redact: string[];
-    maxBytes: number;
-}
-/** Duration is a cooperative access lease, not physical erasure or revocation of
- * previously exported bytes. Existing archive/history is NEVER deleted. */
-export declare function createReviewedArchiveExport(path: string, raw: ReviewedExportPolicy, policyPermissions: string[]): {
-    preview(now: number): {
-        content: string;
-        digest: string;
-        expiresAt: number;
-    };
-    export(previewDigest: string, reviewPermissions: string[], now: number): {
-        delivery: "local-reviewed-file";
-        previewDigest: string;
-        sha256: string;
-        bytes: number;
-        expiresAt: number;
-        physicalErasure: boolean;
-    };
-};
-export declare function openReviewedArchiveExport(path: string): {
-    preview(now: number): {
-        content: string;
-        digest: string;
-        expiresAt: number;
-    };
-    export(previewDigest: string, reviewPermissions: string[], now: number): {
-        delivery: "local-reviewed-file";
-        previewDigest: string;
-        sha256: string;
-        bytes: number;
-        expiresAt: number;
-        physicalErasure: boolean;
-    };
-};

package/dist/reviewed-archive-export.js

@@ -1,78 +0,0 @@
-import { constants, openSync, closeSync, writeSync, fsyncSync, realpathSync, lstatSync } from 'node:fs';
-import { dirname, isAbsolute, resolve } from 'node:path';
-import { createHash } from 'node:crypto';
-import { learningJournal, learningCopy, learningHash, learningFile } from './learning-journal.js';
-import { readGovernedArchive } from './archive-access.js';
-import { readArchiveSource } from './evidence-archive.js';
-const sha = (b) => createHash('sha256').update(b).digest('hex');
-const credential = /(?:ghp_|github_pat_|sk-(?:live-|proj-)?)[A-Za-z0-9_-]{20,}|-----BEGIN [A-Z ]*PRIVATE KEY-----|authorization\s*:\s*bearer\s+\S+/i;
-/** Duration is a cooperative access lease, not physical erasure or revocation of
- * previously exported bytes. Existing archive/history is NEVER deleted. */
-export function createReviewedArchiveExport(path, raw, policyPermissions) {
-    const policy = learningCopy(raw), digest = learningHash(policy);
-    if (!policyPermissions.includes(digest))
-        throw Error('exact export policy permission required');
-    if (!isAbsolute(policy.archiveRoot) || !isAbsolute(policy.destination) || !Number.isSafeInteger(policy.expiresAt) || policy.expiresAt < 0 || !Number.isSafeInteger(policy.maxBytes) || policy.maxBytes < 1 || policy.maxBytes > 1024 * 1024 || !Array.isArray(policy.manifestIds) || !policy.manifestIds.length || policy.manifestIds.length > 16 || new Set(policy.manifestIds).size !== policy.manifestIds.length || policy.manifestIds.some(s => !/^[a-f0-9]{64}$/.test(s)) || !Array.isArray(policy.redact) || policy.redact.length > 64 || policy.redact.some(s => typeof s !== 'string' || !s.length || s.length > 4096))
-        throw Error('bounded reviewed export policy required');
-    learningJournal(path, { type: 'reviewed-export-v1', policy, policyDigest: digest });
-    return openReviewedArchiveExport(path);
-}
-export function openReviewedArchiveExport(path) {
-    const journal = learningJournal(path), first = journal.read()[0].value, policy = first.policy;
-    if (first.type !== 'reviewed-export-v1' || learningHash(policy) !== first.policyDigest)
-        throw Error('export policy changed');
-    const clock = (now) => { const rows = journal.read(), last = Math.max(0, ...rows.map(r => Number(r.value.now ?? 0))); if (!Number.isSafeInteger(now) || now < last)
-        throw Error('export clock rewind'); journal.append(rows.at(-1).id, { type: 'access', now }); if (now >= policy.expiresAt)
-        throw Error('export access lease expired'); };
-    const render = () => { let total = 0; const sources = policy.manifestIds.map(id => { const read = policy.access ? readGovernedArchive(policy.archiveRoot, id, policy.maxBytes - total, policy.access) : readArchiveSource(policy.archiveRoot, id, policy.maxBytes - total); if (read.status !== 'available')
-        throw Error('export source unavailable or over bound'); total += read.bytes.length; let content = new TextDecoder('utf-8', { fatal: true }).decode(read.bytes); for (const literal of policy.redact)
-        content = content.split(literal).join('[REDACTED]'); if (credential.test(content))
-        throw Error('credential pattern remains; revise explicit redaction policy'); return { manifestId: id, sourceSha256: sha(read.bytes), exportSha256: sha(content), representation: 'reviewed-view-not-authority', content }; }); const content = JSON.stringify({ version: 'reviewed-archive-export-v1', sources }, null, 2) + '\n'; if (Buffer.byteLength(content) > 2 * policy.maxBytes + 16384)
-        throw Error('redacted export size bound'); return { content, digest: learningHash({ policyDigest: first.policyDigest, content }), expiresAt: policy.expiresAt }; };
-    return { preview(now) { clock(now); const preview = render(), rows = journal.read(); journal.append(rows.at(-1).id, { type: 'previewed', digest: preview.digest, now }); return preview; },
-        export(previewDigest, reviewPermissions, now) {
-            clock(now);
-            if (!reviewPermissions.includes(previewDigest))
-                throw Error('exact reviewed preview permission required');
-            const rows = journal.read();
-            if (!rows.some(r => r.value.type === 'previewed' && r.value.digest === previewDigest))
-                throw Error('preview must precede export');
-            if (rows.some(r => r.value.type === 'export-claimed'))
-                throw Error('export already claimed; no automatic retry');
-            const preview = render();
-            if (preview.digest !== previewDigest)
-                throw Error('preview/source changed');
-            const parent = dirname(policy.destination), stat = lstatSync(parent);
-            if (!stat.isDirectory() || stat.isSymbolicLink() || realpathSync(parent) !== resolve(parent) || (stat.mode & 0o077) || (process.getuid && stat.uid !== process.getuid()))
-                throw Error('private owned export destination required');
-            const claim = journal.append(rows.at(-1).id, { type: 'export-claimed', digest: previewDigest, now });
-            const data = Buffer.from(preview.content), fd = openSync(policy.destination, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-            try {
-                let offset = 0;
-                while (offset < data.length) {
-                    const n = writeSync(fd, data, offset, data.length - offset);
-                    if (!n)
-                        throw Error('export write stalled');
-                    offset += n;
-                }
-                fsyncSync(fd);
-            }
-            finally {
-                closeSync(fd);
-            }
-            const dir = openSync(parent, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-            try {
-                fsyncSync(dir);
-            }
-            finally {
-                closeSync(dir);
-            }
-            if (!learningFile(policy.destination, data.length).equals(data))
-                throw Error('export readback mismatch');
-            const receipt = { delivery: 'local-reviewed-file', previewDigest, sha256: sha(data), bytes: data.length, expiresAt: policy.expiresAt, physicalErasure: false };
-            journal.append(claim.id, { type: 'exported', receipt, now });
-            return receipt;
-        },
-    };
-}
-//# sourceMappingURL=reviewed-archive-export.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