@skill-harness/adapters 0.16.0 → 0.18.0

package/dist/archived-work.js

@@ -1,78 +0,0 @@
-import { readArchiveSource, retainArchiveSource } from "./evidence-archive.js";
-import { projectWorkLedger } from "./generated/work-v4/reader.js";
-import { WORK_V4_READER_COMMIT } from "./generated/work-v4/pin.js";
-import { captureWorkCandidates } from "./work-case-archive.js";
-import { retainWorkSignalObservation } from "./work-signal-observation.js";
-import { captureWorkSignalCases } from "./work-signal-cases.js";
-/** Pinned producer's actual pure reader/projector, with no append/inspect/file-writing API in the generated facade. */
-export function readArchivedWork(root, manifestId, context = { selectedSnapshot: null, authority: null }) {
-    const source = readArchiveSource(root, manifestId);
-    if (source.status !== "available")
-        return { state: source.status === "missing" ? "missing" : "error", manifestId, reason: "work-source-unavailable" };
-    if (source.reference.retention !== "exact" || source.reference.parser.id !== "pi-daddy-work-ledger" || source.reference.parser.version !== "4")
-        return { state: "error", manifestId, reason: "exact-work-v4-source-required" };
-    try {
-        const text = new TextDecoder("utf-8", { fatal: true }).decode(source.bytes);
-        const projection = projectWorkLedger(text, context);
-        return { state: "available", manifestId, sourceSha256: source.reference.sha256, producerCommit: WORK_V4_READER_COMMIT, projection };
-    }
-    catch {
-        return { state: "error", manifestId, reason: "invalid-work-source-or-context" };
-    }
-}
-/** Preserve raw work bytes, derived facts and candidate batch linkage. No authority is read from an archive/context file. */
-export function captureArchivedWorkCandidates(root, manifestId, context, options) {
-    const read = readArchivedWork(root, manifestId, context);
-    if (read.state !== "available" || read.projection.errors.length || read.projection.scopeState !== "valid")
-        throw new Error("work source/selection incomplete; cannot nominate behavior");
-    const cases = captureWorkCandidates(root, read.projection, options);
-    const linkage = { version: "archived-work-candidates-v1", workManifestId: manifestId, workSha256: read.sourceSha256, producerCommit: read.producerCommit,
-        observationId: cases.observationId, caseBatchId: cases.batchId, candidateIds: cases.candidateIds, authorityBasis: "independently-supplied-host-context", acceptance: "not-assessed" };
-    const stored = retainArchiveSource(root, { sourceId: `work-case-link-${read.sourceSha256}`, parser: { id: "archived-work-candidates", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(linkage)) });
-    return { ...linkage, linkageManifestId: stored.manifestId };
-}
-/** Derive binding/coverage/acceptance fields from the real pinned P01 projection, not caller replacements. */
-export function captureArchivedWorkSignals(root, manifestId, context, suppliedFacts) {
-    const read = readArchivedWork(root, manifestId, context);
-    if (read.state !== "available" || read.projection.errors.length || read.projection.scopeState !== "valid" || !read.projection.selectedSnapshot || !read.projection.runtime)
-        throw new Error("work source/selection incomplete; cannot capture signals");
-    const work = read.projection, runtime = read.projection.runtime, snapshotDigest = read.projection.selectedSnapshot.digest;
-    const snapshot = { snapshotDigest, scopeValid: true,
-        obligations: work.obligations.map(o => ({ id: o.binding.obligation.id, digest: o.binding.obligation.digest,
-            intentDigest: o.binding.intent.digest, policyDigest: o.binding.policy.digest, artifactDigest: o.binding.artifact?.digest ?? null,
-            acceptance: o.acceptance,
-            coverage: [o.artifactCoverage.state, o.evidenceCoverage.state].includes("conflicted") ? "conflicted"
-                : [o.artifactCoverage.state, o.evidenceCoverage.state].includes("unavailable") ? "unavailable"
-                    : o.artifactCoverage.state === "available" && o.evidenceCoverage.state === "available" && o.problems.every(p => p.code === "TRUSTED_REJECTION") ? "available" : "unknown" })) };
-    // Null means derive only facts the retained projection itself establishes. Empty arrays are explicit:
-    // runtime failure is not an objective violation, and absence cannot invent a deadline, expected wait,
-    // prior acceptance or authority. Coverage candidates still follow from the projected obligation.
-    const facts = suppliedFacts ?? { scopeDigest: snapshotDigest, version: "observed-work-v1", population: "retained-work",
-        expectedWaits: [], checkpoints: [], violations: [], priorAccepted: [] };
-    const runtimeFacts = {
-        version: "observed-work-runtime-v1", snapshotDigest, sourceManifestId: manifestId,
-        attempts: runtime.attempts.map(attempt => {
-            const eventDigests = runtime.occurrences.filter(occurrence => occurrence.payload.executionId === attempt.executionId &&
-                occurrence.payload.provenance === "observed" && ["completed", "failed", "cancelled"].includes(occurrence.payload.state))
-                .map(occurrence => occurrence.event.digest).sort();
-            return { executionId: attempt.executionId, state: attempt.state, resolution: attempt.resolution,
-                completionEvidence: { state: eventDigests.length ? "available" : "unavailable", eventDigests } };
-        }).sort((a, b) => a.executionId < b.executionId ? -1 : a.executionId > b.executionId ? 1 : 0),
-        obligations: snapshot.obligations.map(obligation => ({ obligationDigest: obligation.digest, acceptance: obligation.acceptance, coverage: obligation.coverage }))
-            .sort((a, b) => a.obligationDigest < b.obligationDigest ? -1 : a.obligationDigest > b.obligationDigest ? 1 : 0),
-        unavailable: ["checkpoint-evidence", "expected-wait-evidence", "prior-acceptance-history"],
-    };
-    const retainedRuntimeFacts = retainArchiveSource(root, { sourceId: `observed-runtime-${read.sourceSha256}`, parser: { id: "observed-work-runtime-facts", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(runtimeFacts)) });
-    // All four digests here are REVISION identities, not artifact content digests.
-    // Duplicate obligation bindings cannot be collapsed by this input profile; its validator refuses them.
-    const observation = retainWorkSignalObservation(root, snapshot, facts);
-    const projection = retainArchiveSource(root, { sourceId: `work-signal-projection-${read.sourceSha256}`, parser: { id: "pi-daddy-work-projection", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(work)) });
-    const cases = captureWorkSignalCases(root, observation.manifestId);
-    const linkage = { version: "archived-work-signals-v1", bindingProfile: "work-v4-revision-digests-v1", workManifestId: manifestId,
-        workSha256: read.sourceSha256, producerCommit: read.producerCommit, projectionManifestId: projection.manifestId,
-        runtimeFactsManifestId: retainedRuntimeFacts.manifestId, observationId: observation.manifestId, caseBatchId: cases.batchId, candidateIds: cases.candidateIds,
-        authorityBasis: "independently-supplied-host-context", acceptance: "not-assessed" };
-    const stored = retainArchiveSource(root, { sourceId: `work-signal-link-${read.sourceSha256}`, parser: { id: "archived-work-signals", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(linkage)) });
-    return { ...linkage, linkageManifestId: stored.manifestId };
-}
-//# sourceMappingURL=archived-work.js.map

package/dist/blind-intervention.d.ts

@@ -1,35 +0,0 @@
-import { type BlindQualityChoice, type InterventionManifest, type InterventionEvidence, type InterventionQualification } from "@skill-harness/core";
-/** Explicit private retention. Host role declarations are NOT authentication. No provider is called. */
-export declare function retainBlindIntervention(root: string, manifest: InterventionManifest, evidence: InterventionEvidence[], qualification: InterventionQualification, author: string): string;
-/** Opaque linkage metadata only; never exposes roles, arm identities or cost before choice. */
-export declare function readBlindInterventionBinding(root: string, id: string, author: string): Readonly<{
-    experimentDigest: string;
-    investigationDigest: string;
-}>;
-/** One immutable quality choice per comparison. Reopening cannot reset the reveal gate. */
-export declare function openBlindIntervention(root: string, id: string, author: string): Readonly<{
-    view: () => {
-        version: string;
-        cards: {
-            label: string;
-            artifactDigests: string[];
-        }[];
-        limitations: string[];
-    };
-    quality(): BlindQualityChoice | null;
-    previewChoice(input: BlindQualityChoice): BlindQualityChoice;
-    readArtifact: (label: string, hash: string) => Buffer<ArrayBuffer>;
-    choose(input: BlindQualityChoice): BlindQualityChoice;
-    reveal(): {
-        manifestId: string;
-        choice: BlindQualityChoice;
-        arms: {
-            label: string;
-            armId: string;
-            configuration: Record<import("@skill-harness/core").InterventionAxis, string>;
-            cost: number | null;
-            costUnit: string;
-        }[];
-        routingDefault: null;
-    };
-}>;

package/dist/blind-intervention.js

@@ -1,218 +0,0 @@
-import { constants, closeSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readSync, writeSync } from "node:fs";
-import { createHash, randomBytes } from "node:crypto";
-import { join } from "node:path";
-import { assessIntervention, createBlindComparison, interventionCanonicalJson } from "@skill-harness/core";
-import { readArchiveSource, retainArchiveSource } from "./evidence-archive.js";
-const SHA = /^[a-f0-9]{64}$/;
-const missing = (e) => e?.code === "ENOENT";
-const encode = interventionCanonicalJson;
-const copy = (value) => JSON.parse(encode(value));
-function keys(value, names) {
-    if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join() !== names.sort().join())
-        throw new Error("invalid blind record fields");
-}
-function authorValid(author) {
-    if (typeof author !== "string" || !author.length || author.length > 512 || /[\u0000-\u001f\u007f]/.test(author))
-        throw new Error("explicit blind author required");
-}
-function claimsValid(claims, manifest) {
-    keys(claims, ["manifestId", "proposer", "judge", "subjects", "evidenceDigests"]);
-    for (const role of [claims.proposer, claims.judge])
-        keys(role, ["requested", "canonical"]);
-    keys(claims.subjects, manifest.arms.map(a => a.id));
-    keys(claims.evidenceDigests, manifest.arms.map(a => a.id));
-    for (const role of Object.values(claims.subjects))
-        keys(role, ["requested", "canonical"]);
-}
-/** Explicit private retention. Host role declarations are NOT authentication. No provider is called. */
-export function retainBlindIntervention(root, manifest, evidence, qualification, author) {
-    authorValid(author);
-    const descriptors = Object.getOwnPropertyDescriptors(qualification);
-    if (Reflect.ownKeys(descriptors).some(k => typeof k !== "string" || !descriptors[k].enumerable || !Object.hasOwn(descriptors[k], "value")))
-        throw new Error("plain qualification required");
-    keys(qualification, ["manifestId", "proposer", "judge", "subjects", "evidenceDigests", "artifacts"]);
-    const { artifacts: artifactDescriptor, ...rest } = descriptors;
-    const claims = copy(Object.fromEntries(Object.entries(rest).map(([k, d]) => [k, d.value])));
-    const stableManifest = copy(manifest), stableEvidence = copy(evidence);
-    claimsValid(claims, stableManifest);
-    if (!(artifactDescriptor.value instanceof Map))
-        throw new Error("retained artifact map required");
-    const artifacts = new Map();
-    let total = 0;
-    for (const [hash, bytes] of Map.prototype.entries.call(artifactDescriptor.value)) {
-        if (typeof hash !== "string" || !SHA.test(hash) || !(bytes instanceof Uint8Array) || bytes.byteLength > 8 * 1024 * 1024 || artifacts.size >= 4096 || (total += bytes.byteLength) > 64 * 1024 * 1024)
-            throw new Error("bounded blind artifacts required");
-        const stable = Buffer.from(bytes);
-        if (createHash("sha256").update(stable).digest("hex") !== hash)
-            throw new Error("blind artifact digest mismatch");
-        artifacts.set(hash, stable);
-    }
-    const assessment = assessIntervention(stableManifest, stableEvidence, { ...claims, artifacts });
-    const seed = randomBytes(32).toString("hex");
-    createBlindComparison(stableManifest, assessment, seed); // Refuse incomplete inputs BEFORE writes.
-    const referenced = new Set(stableEvidence.flatMap(e => e.artifactDigests));
-    if ([...artifacts.keys()].some(h => !referenced.has(h)))
-        throw new Error("unreferenced blind artifact");
-    const refs = [...artifacts].sort(([a], [b]) => a.localeCompare(b)).map(([hash, bytes]) => ({ hash,
-        manifestId: retainArchiveSource(root, { sourceId: `blind-artifact-${hash}`, parser: { id: "blind-artifact", version: "1" }, retention: "exact", bytes }).manifestId }));
-    const bundle = { version: "retained-blind-intervention-v1", manifest: stableManifest, evidence: stableEvidence, qualification: claims, artifacts: refs, seed, author };
-    return retainArchiveSource(root, { sourceId: `blind-${stableManifest.id}`, parser: { id: "blind-intervention", version: "1" }, retention: "exact", bytes: Buffer.from(encode(bundle)) }).manifestId;
-}
-function load(root, id, author) {
-    authorValid(author);
-    const source = readArchiveSource(root, id);
-    if (source.status !== "available" || source.reference.retention !== "exact" || source.reference.parser.id !== "blind-intervention" || source.reference.parser.version !== "1")
-        throw new Error("blind input unavailable");
-    let bundle;
-    try {
-        const text = new TextDecoder("utf-8", { fatal: true }).decode(source.bytes);
-        bundle = JSON.parse(text);
-        if (encode(bundle) !== text)
-            throw new Error();
-    }
-    catch {
-        throw new Error("invalid blind input JSON");
-    }
-    keys(bundle, ["version", "manifest", "evidence", "qualification", "artifacts", "seed", "author"]);
-    if (bundle.version !== "retained-blind-intervention-v1" || bundle.author !== author)
-        throw new Error("blind author or version mismatch");
-    claimsValid(bundle.qualification, bundle.manifest);
-    if (!Array.isArray(bundle.artifacts) || bundle.artifacts.length > 4096)
-        throw new Error("invalid blind artifacts");
-    const artifacts = new Map();
-    let total = 0;
-    for (const ref of bundle.artifacts) {
-        keys(ref, ["hash", "manifestId"]);
-        if (!SHA.test(ref.hash) || artifacts.has(ref.hash))
-            throw new Error("invalid blind artifact identity");
-        const artifact = readArchiveSource(root, ref.manifestId);
-        if (artifact.status !== "available" || artifact.reference.retention !== "exact" || artifact.reference.parser.id !== "blind-artifact" || artifact.reference.parser.version !== "1" || artifact.reference.sha256 !== ref.hash || (total += artifact.bytes.length) > 64 * 1024 * 1024)
-            throw new Error("blind artifact unavailable");
-        artifacts.set(ref.hash, artifact.bytes);
-    }
-    const assessment = assessIntervention(bundle.manifest, bundle.evidence, { ...bundle.qualification, artifacts });
-    return { blind: createBlindComparison(bundle.manifest, assessment, bundle.seed), manifest: bundle.manifest };
-}
-/** Opaque linkage metadata only; never exposes roles, arm identities or cost before choice. */
-export function readBlindInterventionBinding(root, id, author) {
-    const { manifest } = load(root, id, author);
-    return Object.freeze({ experimentDigest: manifest.id, investigationDigest: manifest.investigationSha256 });
-}
-function directory(path) {
-    const s = lstatSync(path);
-    if (!s.isDirectory() || s.isSymbolicLink() || (s.mode & 0o077) || (process.getuid && s.uid !== process.getuid()))
-        throw new Error("private blind directory required");
-}
-function syncDirectory(path) {
-    const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-    try {
-        fsyncSync(fd);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function readChoice(root, id) {
-    const parent = join(root, "blind-decisions"), dir = join(parent, id);
-    try {
-        directory(parent);
-        directory(dir);
-    }
-    catch (e) {
-        if (missing(e))
-            return null;
-        throw e;
-    }
-    let fd;
-    try {
-        fd = openSync(join(dir, "choice.json"), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-    }
-    catch (e) {
-        if (missing(e))
-            throw new Error("blind choice incomplete; explicit recovery required");
-        throw e;
-    }
-    try {
-        const s = fstatSync(fd);
-        if (!s.isFile() || s.nlink !== 1 || (s.mode & 0o077) || (process.getuid && s.uid !== process.getuid()) || s.size > 16384)
-            throw new Error("invalid blind choice file");
-        const bytes = Buffer.alloc(16385);
-        let used = 0;
-        while (used < bytes.length) {
-            const n = readSync(fd, bytes, used, bytes.length - used, used);
-            if (!n)
-                break;
-            used += n;
-        }
-        if (used > 16384)
-            throw new Error("invalid blind choice bound");
-        try {
-            const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, used));
-            const value = JSON.parse(text);
-            if (encode(value) !== text)
-                throw new Error();
-            return value;
-        }
-        catch {
-            throw new Error("invalid blind choice JSON; explicit recovery required");
-        }
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-/** One immutable quality choice per comparison. Reopening cannot reset the reveal gate. */
-export function openBlindIntervention(root, id, author) {
-    if (!SHA.test(id))
-        throw new Error("invalid blind comparison identity");
-    const current = () => load(root, id, author).blind;
-    return Object.freeze({
-        view: () => current().view(),
-        quality() { const blind = current(), choice = readChoice(root, id); return choice ? blind.choose(choice) : null; },
-        previewChoice(input) { return current().choose(input); },
-        readArtifact: (label, hash) => current().readArtifact(label, hash),
-        choose(input) {
-            const blind = current(), choice = blind.choose(input);
-            const before = readChoice(root, id);
-            if (before) {
-                blind.choose(before);
-                if (encode(before) !== encode(choice))
-                    throw new Error("blind quality choice locked");
-                return before;
-            }
-            const parent = join(root, "blind-decisions"), dir = join(parent, id);
-            try {
-                mkdirSync(parent, { mode: 0o700 });
-            }
-            catch (e) {
-                if (e.code !== "EEXIST")
-                    throw e;
-            }
-            directory(parent);
-            // Atomic mkdir is the single-writer claim. Never remove or recover an incomplete claim automatically.
-            mkdirSync(dir, { mode: 0o700 });
-            const fd = openSync(join(dir, "choice.json"), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-            try {
-                const data = Buffer.from(encode(choice));
-                let offset = 0;
-                while (offset < data.length) {
-                    const n = writeSync(fd, data, offset, data.length - offset);
-                    if (!n)
-                        throw new Error("blind choice write stalled");
-                    offset += n;
-                }
-                fsyncSync(fd);
-            }
-            finally {
-                closeSync(fd);
-            }
-            syncDirectory(dir);
-            syncDirectory(parent);
-            syncDirectory(root);
-            return choice;
-        },
-        reveal() { const blind = current(), choice = readChoice(root, id); if (!choice)
-            throw new Error("durable quality choice required before reveal"); blind.choose(choice); return blind.reveal(); },
-    });
-}
-//# sourceMappingURL=blind-intervention.js.map

package/dist/codex-diagnostic-model.d.ts

@@ -1,14 +0,0 @@
-import type { CodexSdkBinding } from './codex-sdk-transport.js';
-export interface CodexDiagnosticModelPin {
-    path: string;
-    sha256: string;
-}
-/** Local catalogue declaration only, NOT canonical resolution or account entitlement. */
-export declare function validateCodexDiagnosticModel(raw: unknown): CodexSdkBinding['model'];
-export declare function loadCodexDiagnosticModel(pin: CodexDiagnosticModelPin): {
-    [key: string]: unknown;
-    id: string;
-    provider: string;
-    api: string;
-    baseUrl: string;
-};

package/dist/codex-diagnostic-model.js

@@ -1,39 +0,0 @@
-import { createHash } from 'node:crypto';
-import { isAbsolute } from 'node:path';
-import { learningCopy, learningFile } from './learning-journal.js';
-const closed = (v, keys) => { if (!v || typeof v !== 'object' || Array.isArray(v) || Object.keys(v).sort().join() !== keys.sort().join())
-    throw Error('closed diagnostic model definition required'); };
-/** Local catalogue declaration only, NOT canonical resolution or account entitlement. */
-export function validateCodexDiagnosticModel(raw) {
-    const m = learningCopy(raw);
-    closed(m, ['id', 'name', 'provider', 'api', 'baseUrl', 'reasoning', 'input', 'cost', 'contextWindow', 'maxTokens', 'thinkingLevelMap', 'compat']);
-    if (m.id !== 'gpt-6-astra' || m.name !== 'GPT-6 Astra' || m.provider !== 'openai-codex' || m.api !== 'openai-codex-responses' || m.baseUrl !== 'https://chatgpt.com/backend-api' || m.reasoning !== true || JSON.stringify(m.input) !== '["text","image"]' || ![m.contextWindow, m.maxTokens].every(n => Number.isSafeInteger(n) && n > 0))
-        throw Error('diagnostic model identity/capability mismatch');
-    closed(m.thinkingLevelMap, ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
-    if (m.thinkingLevelMap.off !== null || m.thinkingLevelMap.minimal !== 'low' || ['low', 'medium', 'high', 'xhigh', 'max'].some(k => m.thinkingLevelMap[k] !== k))
-        throw Error('diagnostic effort mapping mismatch');
-    closed(m.compat, ['supportsOpenAIGrammarTools', 'supportsAdditionalTools', 'supportsToolSearch']);
-    if (!Object.values(m.compat).every(v => typeof v === 'boolean'))
-        throw Error('diagnostic compatibility mismatch');
-    const prices = ['input', 'output', 'cacheRead', 'cacheWrite'];
-    closed(m.cost, [...prices, 'tiers']);
-    if (!Array.isArray(m.cost.tiers) || m.cost.tiers.length > 8)
-        throw Error('diagnostic cost declaration');
-    for (const [i, cost] of [m.cost, ...m.cost.tiers].entries()) {
-        if (i)
-            closed(cost, ['inputTokensAbove', ...prices]);
-        if (![...prices, ...(i ? ['inputTokensAbove'] : [])].every(k => typeof cost[k] === 'number' && Number.isFinite(cost[k]) && cost[k] >= 0))
-            throw Error('diagnostic cost declaration');
-    }
-    return m;
-}
-export function loadCodexDiagnosticModel(pin) {
-    closed(pin, ['path', 'sha256']);
-    if (typeof pin.path !== 'string' || !isAbsolute(pin.path) || !/^[a-f0-9]{64}$/.test(pin.sha256))
-        throw Error('diagnostic definition pin required');
-    const bytes = learningFile(pin.path, 8192);
-    if (createHash('sha256').update(bytes).digest('hex') !== pin.sha256)
-        throw Error('diagnostic definition source mismatch');
-    return validateCodexDiagnosticModel(JSON.parse(bytes.toString('utf8')));
-}
-//# sourceMappingURL=codex-diagnostic-model.js.map

package/dist/codex-host-observer.d.ts

@@ -1,111 +0,0 @@
-import type { Readable, Writable } from 'node:stream';
-import { type CodexSdkBinding, type CodexWireTransport } from './codex-sdk-transport.js';
-/** LOCAL host protocol with an inert installed-SDK seam; no auth loader or live network switch.
- * The trusted host owns this module and transport streams; the subject gets framed IPC only.
- * Stream finish proves a host-side write, NOT provider receipt, backend identity or token limits.
- * Journal integrity assumes a trusted cooperative host/filesystem, not hostile same-UID rollback. */
-export declare const CODEX_SUBSCRIPTION_DESTINATION = "https://chatgpt.com/backend-api/codex/responses";
-type Role = 'proposer' | 'subject' | 'judge';
-export interface LocalCodexInvocation {
-    id: string;
-    role: Role;
-    model: string;
-    effort: 'low' | 'medium' | 'high';
-    instructions: string;
-    input: string;
-    expectedSha256: string;
-    subjectId: string | null;
-}
-export interface LocalCodexHostSpec {
-    version: 'codex-host-local-v1';
-    maxCalls: number;
-    wallMs: number;
-    invocations: LocalCodexInvocation[];
-}
-export interface SubscriptionReservations {
-    charterSha256: string;
-    mode: 'fixture' | 'subscription-live';
-    requestBytes: number;
-    responseBytes: number;
-    totalRequestBytes: number;
-    totalResponseBytes: number;
-    callMs: number;
-}
-export interface LocalCodexObservation {
-    id: string;
-    sequence: number;
-    requestBody: string;
-    requestSha256: string;
-    outputBase64: string;
-    outputSha256: string;
-    objective: 'PASS' | 'FAIL';
-    providerInternalFacts: null;
-    liveQualified: false;
-}
-/** This checks supplied policy consistency, never authenticates its source or invents lineage. */
-export declare function inspectCodexRoleSeparation(raw: Array<{
-    role: Role;
-    model: string;
-    canonical: string | null;
-    lineage: string | null;
-}>): {
-    state: "BLOCKED";
-    reason: string;
-    liveQualified: false;
-} | {
-    state: "CONSISTENT_DECLARATION_ONLY";
-    reason: string;
-    disclosures: string[];
-    liveQualified: false;
-};
-export declare function createLocalCodexHost(path: string, input: LocalCodexHostSpec, rolePolicy?: Parameters<typeof inspectCodexRoleSeparation>[0], subscription?: SubscriptionReservations): {
-    inspect: () => {
-        calls: number;
-        complete: boolean;
-        aborted: boolean;
-        liveQualified: false;
-    };
-    exchangeSubscriptionSdk(subjectFrames: Readable, binding: CodexSdkBinding, transport: CodexWireTransport, charterSha256: string, sourceSignal?: AbortSignal): Promise<LocalCodexObservation>;
-    exchangeSdk(subjectFrames: Readable, binding: CodexSdkBinding, fixture: () => Promise<Response>): Promise<LocalCodexObservation>;
-    exchange(subjectFrames: Readable, hostTransport: Writable, hostResponse: Readable, subscriptionMode?: boolean, sourceSignal?: AbortSignal): Promise<LocalCodexObservation>;
-    panel(subjectId: string, judgeIds: string[], rawPolicy: Parameters<typeof inspectCodexRoleSeparation>[0]): {
-        label: string;
-        collapse: import("@skill-harness/core").VotePanelCollapse;
-        identityStatus: "CONSISTENT_DECLARATION_ONLY";
-        disclosures: string[];
-        liveQualified: false;
-        routingDefault: null;
-    };
-    eligibleOutputs(): {
-        label: string;
-        outputBase64: string;
-        outputSha256: string;
-        liveQualified: false;
-    }[];
-};
-export declare function openLocalCodexHost(path: string): {
-    inspect: () => {
-        calls: number;
-        complete: boolean;
-        aborted: boolean;
-        liveQualified: false;
-    };
-    exchangeSubscriptionSdk(subjectFrames: Readable, binding: CodexSdkBinding, transport: CodexWireTransport, charterSha256: string, sourceSignal?: AbortSignal): Promise<LocalCodexObservation>;
-    exchangeSdk(subjectFrames: Readable, binding: CodexSdkBinding, fixture: () => Promise<Response>): Promise<LocalCodexObservation>;
-    exchange(subjectFrames: Readable, hostTransport: Writable, hostResponse: Readable, subscriptionMode?: boolean, sourceSignal?: AbortSignal): Promise<LocalCodexObservation>;
-    panel(subjectId: string, judgeIds: string[], rawPolicy: Parameters<typeof inspectCodexRoleSeparation>[0]): {
-        label: string;
-        collapse: import("@skill-harness/core").VotePanelCollapse;
-        identityStatus: "CONSISTENT_DECLARATION_ONLY";
-        disclosures: string[];
-        liveQualified: false;
-        routingDefault: null;
-    };
-    eligibleOutputs(): {
-        label: string;
-        outputBase64: string;
-        outputSha256: string;
-        liveQualified: false;
-    }[];
-};
-export {};