@skill-harness/adapters 0.11.0 → 0.13.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/closed-schema.d.ts

@@ -33,6 +33,8 @@ type Schema = Record<string, unknown>;
  * a keyword fails loudly rather than validating less than it claims.
  */
 export declare function assertSupportedSchema(schema: unknown, label: string, path?: string): void;
+/** V3-only evaluator profile; the frozen v2 profile above remains unchanged. */
+export declare function assertSupportedSchemaV3(schema: unknown, label: string, path?: string): void;
 /**
  * Validate `value` against `schema`. Returns every violation found; an empty
  * array means the instance satisfies the pinned contract.
@@ -45,6 +47,10 @@ export declare function assertSupportedSchema(schema: unknown, label: string, pa
 export declare function validateClosedSchema(schema: Schema, value: unknown, options?: {
     knownFieldNames?: ReadonlySet<string>;
 }): SchemaViolation[];
+/** Evaluate the additional closed constructs used by the separately pinned v3 schema. */
+export declare function validateClosedSchemaV3(schema: Schema, value: unknown, options?: {
+    knownFieldNames?: ReadonlySet<string>;
+}): SchemaViolation[];
 /** Every property name declared anywhere in the document — safe to echo. */
 export declare function declaredPropertyNames(schema: unknown): Set<string>;
 export {};

package/dist/closed-schema.js

@@ -31,6 +31,11 @@ const SUPPORTED_KEYWORDS = new Set([
     // value constraints
     "enum", "const", "minLength", "maxLength", "minimum", "pattern", "format",
 ]);
+/** Ledger v3 adds only closed composition/conditionals and property-name schemas. */
+const V3_SUPPORTED_KEYWORDS = new Set([
+    ...SUPPORTED_KEYWORDS,
+    "allOf", "anyOf", "if", "then", "propertyNames", "minItems", "maxItems",
+]);
 /**
  * The shape each supported keyword must have. A keyword whose *name* is known but
  * whose *value* has an unexpected shape is the same hole as an unknown keyword:
@@ -40,6 +45,11 @@ const SUPPORTED_KEYWORDS = new Set([
 const KEYWORD_SHAPES = {
     $ref: { check: (value) => typeof value === "string", expected: "a string" },
     oneOf: { check: (value) => Array.isArray(value) && value.length > 0, expected: "a non-empty array" },
+    allOf: { check: (value) => Array.isArray(value) && value.length > 0, expected: "a non-empty array" },
+    anyOf: { check: (value) => Array.isArray(value) && value.length > 0, expected: "a non-empty array" },
+    if: { check: (value) => isSchemaObject(value), expected: "a schema object" },
+    then: { check: (value) => isSchemaObject(value), expected: "a schema object" },
+    propertyNames: { check: (value) => isSchemaObject(value), expected: "a schema object" },
     type: { check: (value) => typeof value === "string" || (Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string")), expected: "a string or array of strings" },
     properties: { check: (value) => isSchemaObject(value), expected: "an object" },
     required: { check: (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string"), expected: "an array of strings" },
@@ -49,6 +59,8 @@ const KEYWORD_SHAPES = {
     minLength: { check: (value) => typeof value === "number", expected: "a number" },
     maxLength: { check: (value) => typeof value === "number", expected: "a number" },
     minimum: { check: (value) => typeof value === "number", expected: "a number" },
+    minItems: { check: (value) => Number.isInteger(value) && Number(value) >= 0, expected: "a non-negative integer" },
+    maxItems: { check: (value) => Number.isInteger(value) && Number(value) >= 0, expected: "a non-negative integer" },
     pattern: { check: (value) => typeof value === "string", expected: "a string" },
     format: { check: (value) => typeof value === "string", expected: "a string" },
     // `const` may legitimately be any JSON value, including null.
@@ -61,12 +73,20 @@ const SUPPORTED_TYPES = new Set(["object", "array", "string", "number", "integer
  * a keyword fails loudly rather than validating less than it claims.
  */
 export function assertSupportedSchema(schema, label, path = "#") {
+    assertSchemaSupported(schema, label, path, false);
+}
+/** V3-only evaluator profile; the frozen v2 profile above remains unchanged. */
+export function assertSupportedSchemaV3(schema, label, path = "#") {
+    assertSchemaSupported(schema, label, path, true);
+}
+function assertSchemaSupported(schema, label, path, v3) {
     if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
         throw new Error(`${label} is not a JSON Schema object at ${path}`);
     }
     const node = schema;
+    const supported = v3 ? V3_SUPPORTED_KEYWORDS : SUPPORTED_KEYWORDS;
     for (const keyword of Object.keys(node)) {
-        if (!SUPPORTED_KEYWORDS.has(keyword)) {
+        if (!supported.has(keyword)) {
             throw new Error(`${label} uses unsupported JSON Schema keyword \`${keyword}\` at ${path}; the closed-contract evaluator refuses to validate less than the schema declares`);
         }
         const shape = KEYWORD_SHAPES[keyword];
@@ -94,15 +114,20 @@ export function assertSupportedSchema(schema, label, path = "#") {
         }
     }
     for (const [name, entry] of Object.entries(object(node.$defs) ?? {}))
-        assertSupportedSchema(entry, label, `${path}/$defs/${name}`);
-    for (const [index, entry] of (Array.isArray(node.oneOf) ? node.oneOf : []).entries())
-        assertSupportedSchema(entry, label, `${path}/oneOf/${index}`);
+        assertSchemaSupported(entry, label, `${path}/$defs/${name}`, v3);
+    for (const keyword of ["oneOf", "allOf", "anyOf"]) {
+        for (const [index, entry] of (Array.isArray(node[keyword]) ? node[keyword] : []).entries()) {
+            assertSchemaSupported(entry, label, `${path}/${keyword}/${index}`, v3);
+        }
+    }
     for (const [name, entry] of Object.entries(object(node.properties) ?? {}))
-        assertSupportedSchema(entry, label, `${path}/properties/${name}`);
-    if (node.items !== undefined)
-        assertSupportedSchema(node.items, label, `${path}/items`);
+        assertSchemaSupported(entry, label, `${path}/properties/${name}`, v3);
+    for (const keyword of ["items", "propertyNames", "if", "then"]) {
+        if (node[keyword] !== undefined)
+            assertSchemaSupported(node[keyword], label, `${path}/${keyword}`, v3);
+    }
     if (node.additionalProperties !== undefined && node.additionalProperties !== false && node.additionalProperties !== true) {
-        assertSupportedSchema(node.additionalProperties, label, `${path}/additionalProperties`);
+        assertSchemaSupported(node.additionalProperties, label, `${path}/additionalProperties`, v3);
     }
 }
 /**
@@ -117,6 +142,10 @@ export function assertSupportedSchema(schema, label, path = "#") {
 export function validateClosedSchema(schema, value, options = {}) {
     return validate(schema, schema, value, "", options.knownFieldNames ?? new Set());
 }
+/** Evaluate the additional closed constructs used by the separately pinned v3 schema. */
+export function validateClosedSchemaV3(schema, value, options = {}) {
+    return validate(schema, schema, value, "", options.knownFieldNames ?? new Set());
+}
 /** Every property name declared anywhere in the document — safe to echo. */
 export function declaredPropertyNames(schema) {
     const names = new Set();
@@ -130,10 +159,13 @@ export function declaredPropertyNames(schema) {
         }
         for (const entry of Object.values(object(current.$defs) ?? {}))
             walk(entry);
-        for (const entry of Array.isArray(current.oneOf) ? current.oneOf : [])
-            walk(entry);
-        if (current.items !== undefined)
-            walk(current.items);
+        for (const keyword of ["oneOf", "allOf", "anyOf"]) {
+            for (const entry of Array.isArray(current[keyword]) ? current[keyword] : [])
+                walk(entry);
+        }
+        for (const keyword of ["items", "propertyNames", "if", "then"])
+            if (current[keyword] !== undefined)
+                walk(current[keyword]);
         if (current.additionalProperties && typeof current.additionalProperties === "object")
             walk(current.additionalProperties);
     };
@@ -146,6 +178,18 @@ function validate(root, schema, value, path, known) {
         return validate(root, resolved, value, path, known);
     }
     const violations = [];
+    if (Array.isArray(schema.allOf)) {
+        for (const branch of schema.allOf)
+            violations.push(...validate(root, branch, value, path, known));
+    }
+    if (Array.isArray(schema.anyOf)) {
+        const branches = schema.anyOf.map((branch) => validate(root, branch, value, path, known));
+        if (!branches.some((branch) => branch.length === 0))
+            violations.push(...bestBranch(root, schema.anyOf, branches, value, path));
+    }
+    if (schema.if !== undefined && validate(root, schema.if, value, path, known).length === 0 && schema.then !== undefined) {
+        violations.push(...validate(root, schema.then, value, path, known));
+    }
     const types = typeList(schema);
     if (types.length && !types.some((type) => matchesType(type, value))) {
         return [{ path, message: `must be ${describeTypes(types)}` }];
@@ -169,8 +213,16 @@ function validate(root, schema, value, path, known) {
         violations.push(...validateString(schema, value, path));
     if (typeof value === "number")
         violations.push(...validateNumber(schema, value, path));
-    if (Array.isArray(value) && schema.items !== undefined) {
-        value.forEach((entry, index) => violations.push(...validate(root, schema.items, entry, `${path}[${index}]`, known)));
+    if (Array.isArray(value)) {
+        if (typeof schema.minItems === "number" && value.length < schema.minItems) {
+            violations.push({ path, message: `must contain at least ${schema.minItems} item(s)` });
+        }
+        if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
+            violations.push({ path, message: `must contain at most ${schema.maxItems} item(s)` });
+        }
+        if (schema.items !== undefined) {
+            value.forEach((entry, index) => violations.push(...validate(root, schema.items, entry, `${path}[${index}]`, known)));
+        }
     }
     const record = object(value);
     if (record)
@@ -180,6 +232,10 @@ function validate(root, schema, value, path, known) {
 function validateObject(root, schema, record, path, known) {
     const violations = [];
     const properties = object(schema.properties) ?? {};
+    if (schema.propertyNames !== undefined) {
+        for (const name of Object.keys(record))
+            violations.push(...validate(root, schema.propertyNames, name, path, known));
+    }
     for (const name of (Array.isArray(schema.required) ? schema.required : [])) {
         if (!Object.hasOwn(record, name))
             violations.push({ path: child(path, name), message: "is required" });

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 {};