@skill-harness/adapters 0.12.0 → 0.14.0

package/dist/blind-intervention.js

@@ -0,0 +1,211 @@
+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);
+    }
+    return createBlindComparison(bundle.manifest, assessIntervention(bundle.manifest, bundle.evidence, { ...bundle.qualification, artifacts }), bundle.seed);
+}
+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);
+    return Object.freeze({
+        view: () => current().view(),
+        quality() { const blind = current(), choice = readChoice(root, id); return choice ? blind.choose(choice) : null; },
+        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

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

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

@@ -0,0 +1,111 @@
+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 {};