@skill-harness/core 0.17.0 → 0.18.0

package/dist/qualification-store.js

@@ -1,833 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { closeSync, constants, existsSync, fsyncSync, fstatSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
-import { dirname, extname, join, resolve } from "node:path";
-import { qualificationLockOwnerIsLive, readQualificationLockOwner, reclaimQualificationLock, releaseQualificationLock, tryPublishQualificationLock, } from "./qualification-lock.js";
-import { QUALIFICATION_ACCOUNTING_POLICY, QUALIFICATION_PANEL_ACCOUNTING_POLICY, QUALIFICATION_OAUTH_DIRECTORY_POLICY_V2, QUALIFICATION_TERMINAL_RECEIPT_VERSION_V3, qualificationOAuthDirectoryPolicy, parseQualificationConfig, parseQualificationRequest, qualificationCanonicalJson, qualificationConfigDigest, qualificationSha256, verifyQualificationExecutable, verifyQualificationPins, verifyQualificationResource, } from "./qualification-config.js";
-export const QUALIFICATION_INVOCATION_VERSION = "qualification-invocation-v1";
-export const QUALIFICATION_INVOCATION_VERSION_V2 = "qualification-invocation-v2";
-export const QUALIFICATION_INVOCATION_VERSION_V3 = "qualification-invocation-v3";
-export const QUALIFICATION_INVOCATION_VERSION_V4 = "qualification-invocation-v4";
-export const QUALIFICATION_INVOCATION_INPUT_BINDING_VERSION = "qualification-invocation-input-binding-v1";
-export const QUALIFICATION_LIFECYCLE_VERSION = "qualification-lifecycle-v1";
-export const QUALIFICATION_ACCOUNTING_VERSION = "qualification-accounting-v1";
-export function qualificationSpoolPaths(spoolDir, invocationId) {
-    if (invocationId !== undefined)
-        assertQualificationIdentifier(invocationId, "invocation_id");
-    const root = resolve(spoolDir);
-    const invocation = invocationId ? join(root, "invocations", invocationId) : undefined;
-    return {
-        root,
-        configuration: join(root, "configuration.json"),
-        accounting: join(root, "accounting.json"),
-        lock: join(root, ".qualification.lock"),
-        invocations: join(root, "invocations"),
-        artifacts: join(root, "artifacts"),
-        invocation,
-        invocationRecord: invocation ? join(invocation, "invocation.json") : undefined,
-        lifecycle: invocation ? join(invocation, "lifecycle.json") : undefined,
-        invocationLock: invocation ? join(invocation, ".lock") : undefined,
-        terminal: invocation ? join(invocation, "terminal") : undefined,
-    };
-}
-export function prepareQualificationInvocation(options) {
-    const config = parseQualificationConfig(parseJsonFile(options.config_path, "qualification configuration"));
-    const request = parseQualificationRequest(parseJsonFile(options.request_path, "qualification invocation request"), config);
-    const approvedConfigSha = qualificationConfigDigest(config);
-    if (config.mode === "production" && (!/^[a-f0-9]{64}$/.test(options.expected_configuration_sha256 ?? "") || options.expected_configuration_sha256 !== approvedConfigSha)) {
-        throw new Error("qualification production prepare requires the externally approved exact configuration SHA-256");
-    }
-    verifyQualificationPins(config);
-    if (options.test_hooks && config.mode !== "test")
-        throw new Error("qualification prepare test hooks are prohibited in production");
-    const now = options.now ?? (() => new Date().toISOString());
-    assertRegularInput(request.scenario.input_path, request.scenario.input_sha256);
-    options.test_hooks?.after_initial_input_validation?.();
-    assertWorkingDirectory(request.scenario.working_directory);
-    const paths = qualificationSpoolPaths(options.spool_dir, request.invocation_id);
-    mkdirSync(paths.root, { recursive: true, mode: 0o700 });
-    assertDirectory(paths.root, "qualification spool");
-    return withQualificationFileLock(paths.lock, () => {
-        mkdirSync(paths.invocations, { recursive: true, mode: 0o700 });
-        mkdirSync(paths.artifacts, { recursive: true, mode: 0o700 });
-        const configSha = approvedConfigSha;
-        initializeSpoolConfiguration(paths.configuration, config, configSha);
-        initializeAccounting(paths.accounting, config.accounting);
-        if (config.judge_panel) {
-            const existingIds = readdirSync(paths.invocations, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-            for (const existingId of existingIds) {
-                const existing = readQualificationInvocation(paths.root, existingId);
-                if (request.panel && existing.panel?.id === request.panel.id && existing.panel.member_ordinal === request.panel.member_ordinal) {
-                    throw new Error(`qualification panel ${request.panel.id} already has member ordinal ${request.panel.member_ordinal}`);
-                }
-                if (request.role === "subject" && existing.role === "subject" && existing.scenario.id === request.scenario.id &&
-                    existing.repetition === request.repetition && existing.arms.selected === request.selected_arm) {
-                    throw new Error("qualification approved board already has this subject scenario/arm/repetition invocation");
-                }
-            }
-        }
-        const expectedArtifact = `artifacts/${request.invocation_id}.jsonl`;
-        const artifactPath = join(paths.root, expectedArtifact);
-        if (existsSync(artifactPath))
-            throw new Error(`qualification artifact path already exists: ${expectedArtifact}`);
-        try {
-            mkdirSync(paths.invocation, { mode: 0o700 });
-        }
-        catch (error) {
-            if (error.code === "EEXIST")
-                throw new Error(`duplicate invocation id ${request.invocation_id}`);
-            throw error;
-        }
-        try {
-            const selected = config.arms.find((arm) => arm.id === request.selected_arm);
-            const executableIdentity = verifyQualificationExecutable(selected.executable);
-            const preparedResources = selected.resources.map((resource, index) => {
-                verifyQualificationResource(resource);
-                const suffix = extname(resource.path).replace(/[^A-Za-z0-9.]/g, "");
-                const path = join(paths.invocation, "resources", `${String(index).padStart(4, "0")}${suffix}`);
-                atomicWriteBytes(path, readFileSync(resource.path), true);
-                return { ...resource, path };
-            });
-            const workingStat = lstatSync(request.scenario.working_directory);
-            const workingDirectoryIdentity = { realpath: realpathSync(request.scenario.working_directory), device: workingStat.dev, inode: workingStat.ino };
-            // Snapshot the already-digested private input before publishing the immutable
-            // invocation record. The child never races a later edit to the coordinator's
-            // source path; the spool copy is the launch material bound by input_sha256.
-            const preparedInputPath = join(paths.invocation, "input.bin");
-            const exactInputBytes = readExactSourceInput(request.scenario.input_path, request.scenario.input_sha256);
-            let parsedInput;
-            if (config.terminal_receipt_version === QUALIFICATION_TERMINAL_RECEIPT_VERSION_V3) {
-                try {
-                    parsedInput = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(exactInputBytes));
-                }
-                catch {
-                    throw new Error("qualification terminal receipt v3 invocation input must be valid UTF-8 application/json bytes");
-                }
-            }
-            if (request.panel && !jsonContainsExactString(parsedInput, request.panel.subject_artifact_sha256)) {
-                throw new Error("qualification judge-panel input must structurally contain its bound subject artifact SHA-256");
-            }
-            atomicWriteBytes(preparedInputPath, exactInputBytes, true);
-            const oauthDirectoryPolicy = qualificationOAuthDirectoryPolicy(config);
-            const v3Input = config.terminal_receipt_version === QUALIFICATION_TERMINAL_RECEIPT_VERSION_V3
-                ? inspectQualificationInvocationInput(preparedInputPath)
-                : null;
-            const baseRecord = {
-                schema_version: v3Input
-                    ? request.panel ? QUALIFICATION_INVOCATION_VERSION_V4 : QUALIFICATION_INVOCATION_VERSION_V3
-                    : oauthDirectoryPolicy === QUALIFICATION_OAUTH_DIRECTORY_POLICY_V2
-                        ? QUALIFICATION_INVOCATION_VERSION_V2
-                        : QUALIFICATION_INVOCATION_VERSION,
-                ...(oauthDirectoryPolicy === QUALIFICATION_OAUTH_DIRECTORY_POLICY_V2
-                    ? { oauth_directory_policy: QUALIFICATION_OAUTH_DIRECTORY_POLICY_V2 }
-                    : {}),
-                ...(v3Input ? {
-                    terminal_receipt_version: QUALIFICATION_TERMINAL_RECEIPT_VERSION_V3,
-                    invocation_input: v3Input.binding,
-                    invocation_input_occurrence: v3Input.occurrence,
-                    prepared_attempt: 0,
-                    accounting_event_sha256: null,
-                } : {}),
-                invocation_id: request.invocation_id,
-                measurement_identity_sha256: request.measurement_identity_sha256,
-                continuation_authority_sha256: request.continuation_authority_sha256,
-                continuation_authority_expires_at: request.continuation_authority_expires_at,
-                scenario: { ...structuredClone(request.scenario), input_path: preparedInputPath },
-                role: request.role,
-                counts_as_measurement: request.counts_as_measurement,
-                arms: { subject: request.arms.subject, judge: request.arms.judge, selected: request.selected_arm },
-                repetition: request.repetition,
-                ...(request.panel ? { panel: structuredClone(request.panel) } : {}),
-                requested: { provider: selected.provider, model: selected.model },
-                authentication: selected.authentication,
-                pins: {
-                    product: structuredClone(config.product),
-                    engine: structuredClone(config.engine),
-                    producer: structuredClone(config.producer),
-                    runner: structuredClone(config.runner),
-                },
-                configuration_sha256: configSha,
-                created_at: validTimestamp(now(), "qualification creation time"),
-                ceiling_policy: structuredClone(config.accounting),
-                execution: {
-                    executable: structuredClone(selected.executable),
-                    executable_identity: executableIdentity,
-                    resources: preparedResources,
-                    working_directory_identity: workingDirectoryIdentity,
-                    arguments: [...selected.arguments],
-                    allowed_environment_names: [...selected.allowed_environment_names],
-                    timeout_ms: selected.timeout_ms,
-                    output_limit_bytes: selected.output_limit_bytes,
-                    fallback: false,
-                    metered_override: false,
-                },
-                expected_artifact: { path: expectedArtifact, type: "pi-jsonl" },
-            };
-            const record = {
-                ...baseRecord,
-                invocation_sha256: qualificationSha256(qualificationCanonicalJson(baseRecord)),
-            };
-            atomicWriteCanonical(paths.invocationRecord, record, true);
-            atomicWriteCanonical(paths.lifecycle, createQualificationLifecycle(record.invocation_id, record.created_at), true);
-            return record;
-        }
-        catch (error) {
-            rmSync(paths.invocation, { recursive: true, force: true });
-            throw error;
-        }
-    });
-}
-export function readQualificationInvocation(spoolDir, invocationId) {
-    const path = qualificationSpoolPaths(spoolDir, invocationId).invocationRecord;
-    const value = readCanonicalJson(path, `qualification invocation ${invocationId}`);
-    validateQualificationInvocationRecord(value);
-    if (value.invocation_id !== invocationId)
-        throw new Error(`qualification invocation ${invocationId} record identity mismatch`);
-    if (isInputBoundInvocation(value))
-        verifyQualificationInvocationInput(value);
-    return value;
-}
-export function readQualificationLifecycle(spoolDir, invocationId) {
-    const path = qualificationSpoolPaths(spoolDir, invocationId).lifecycle;
-    const value = readCanonicalJson(path, `qualification lifecycle ${invocationId}`);
-    return validateQualificationLifecycle(value, invocationId);
-}
-export function writeQualificationLifecycle(spoolDir, lifecycle) {
-    validateQualificationLifecycle(lifecycle, lifecycle.invocation_id);
-    atomicWriteCanonical(qualificationSpoolPaths(spoolDir, lifecycle.invocation_id).lifecycle, lifecycle, false);
-}
-export function transitionQualificationLifecycle(lifecycle, to, options) {
-    validateQualificationLifecycle(lifecycle, lifecycle.invocation_id);
-    const allowed = {
-        prepared: ["launch-claimed", "terminal"],
-        "launch-claimed": ["running", "terminal"],
-        running: ["terminal"],
-        terminal: [],
-    };
-    if (!allowed[lifecycle.phase].includes(to))
-        throw new Error(`illegal qualification lifecycle transition ${lifecycle.phase} -> ${to}`);
-    const terminalStatus = to === "terminal" ? options.terminal_status ?? null : null;
-    if (to === "terminal" && !terminalStatus)
-        throw new Error("qualification terminal transition requires terminal_status");
-    if (to !== "terminal" && options.terminal_status)
-        throw new Error("qualification nonterminal transition cannot carry terminal_status");
-    const base = {
-        seq: lifecycle.events.length + 1,
-        from: lifecycle.phase,
-        to,
-        terminal_status: terminalStatus,
-        at: validTimestamp(options.at, "qualification lifecycle time"),
-        detail: sanitizeDetail(options.detail ?? {}),
-        previous_sha256: lifecycle.chain_head,
-    };
-    const event = { ...base, event_sha256: qualificationSha256(qualificationCanonicalJson(base)) };
-    return {
-        ...lifecycle,
-        phase: to,
-        terminal_status: terminalStatus,
-        events: [...lifecycle.events, event],
-        chain_head: event.event_sha256,
-    };
-}
-export function createQualificationAccountingLedger(policy = QUALIFICATION_ACCOUNTING_POLICY) {
-    assertKnownAccountingPolicy(policy);
-    return {
-        schema_version: QUALIFICATION_ACCOUNTING_VERSION,
-        policy: structuredClone(policy),
-        events: [],
-        chain_head: null,
-    };
-}
-export function appendQualificationAccountingEvent(inputLedger, input) {
-    const report = validateQualificationAccountingLedger(inputLedger);
-    validateAccountingInput(input);
-    if (inputLedger.events.some((event) => event.invocation_id === input.invocation_id)) {
-        throw new Error(`duplicate invocation id ${input.invocation_id} in qualification accounting ledger`);
-    }
-    const next = report.counts[input.call_class] + 1;
-    const ceiling = inputLedger.policy.ceilings[input.call_class];
-    if (next > ceiling)
-        throw new Error(`qualification ${input.call_class} ceiling ${ceiling} would be exceeded before launch claim`);
-    const base = {
-        seq: inputLedger.events.length + 1,
-        invocation_id: input.invocation_id,
-        role: input.role,
-        call_class: input.call_class,
-        counts_as_measurement: input.counts_as_measurement,
-        launched_at: validTimestamp(input.launched_at, "qualification accounting launch time"),
-        previous_sha256: inputLedger.chain_head,
-    };
-    const event = { ...base, event_sha256: qualificationSha256(qualificationCanonicalJson(base)) };
-    return { ...inputLedger, events: [...inputLedger.events, event], chain_head: event.event_sha256 };
-}
-export function validateQualificationAccountingLedger(value) {
-    if (!plainObject(value))
-        throw new Error("qualification accounting ledger must be an object");
-    exactObjectKeys(value, ["schema_version", "policy", "events", "chain_head"], "qualification accounting ledger");
-    if (value.schema_version !== QUALIFICATION_ACCOUNTING_VERSION)
-        throw new Error(`unsupported qualification accounting schema ${String(value.schema_version)}`);
-    assertKnownAccountingPolicy(value.policy);
-    const policy = value.policy;
-    if (!Array.isArray(value.events))
-        throw new Error("qualification accounting events must be an array");
-    let previous = null;
-    const ids = new Set();
-    const roles = {};
-    const counts = { subject: 0, judge: 0, measurement: 0, total: 0 };
-    value.events.forEach((raw, index) => {
-        if (!plainObject(raw))
-            throw new Error(`qualification accounting event ${index + 1} must be an object`);
-        exactObjectKeys(raw, ["seq", "invocation_id", "role", "call_class", "counts_as_measurement", "launched_at", "previous_sha256", "event_sha256"], `qualification accounting event ${index + 1}`);
-        const input = raw;
-        validateAccountingInput(input);
-        if (input.seq !== index + 1)
-            throw new Error(`qualification accounting sequence is reordered or non-contiguous at event ${index + 1}`);
-        if (input.previous_sha256 !== previous)
-            throw new Error(`qualification accounting hash chain is broken at event ${index + 1}`);
-        const { event_sha256, ...base } = input;
-        if (!/^[a-f0-9]{64}$/.test(String(event_sha256)) || qualificationSha256(qualificationCanonicalJson(base)) !== event_sha256) {
-            throw new Error(`qualification accounting event ${index + 1} digest mismatch`);
-        }
-        if (ids.has(input.invocation_id))
-            throw new Error(`duplicate invocation id ${input.invocation_id} in qualification accounting ledger`);
-        ids.add(input.invocation_id);
-        previous = event_sha256;
-        counts[input.call_class] += 1;
-        counts.total += 1;
-        if (input.counts_as_measurement)
-            counts.measurement += 1;
-        roles[input.role] = (roles[input.role] ?? 0) + 1;
-        if (counts[input.call_class] > policy.ceilings[input.call_class]) {
-            throw new Error(`qualification ${input.call_class} ceiling ${policy.ceilings[input.call_class]} exceeded`);
-        }
-    });
-    if (value.chain_head !== previous)
-        throw new Error("qualification accounting chain head does not match the event ledger");
-    return { counts, roles, chain_head: previous };
-}
-export function readQualificationAccounting(spoolDir) {
-    const path = qualificationSpoolPaths(spoolDir).accounting;
-    const value = readCanonicalJson(path, "qualification accounting ledger");
-    validateQualificationAccountingLedger(value);
-    return value;
-}
-export function writeQualificationAccounting(spoolDir, ledger) {
-    validateQualificationAccountingLedger(ledger);
-    atomicWriteCanonical(qualificationSpoolPaths(spoolDir).accounting, ledger, false);
-}
-export function validateQualificationSpool(spoolDir) {
-    const paths = qualificationSpoolPaths(spoolDir);
-    const envelope = readCanonicalJson(paths.configuration, "qualification spool configuration");
-    if (!plainObject(envelope))
-        throw new Error("qualification spool configuration must be an object");
-    exactObjectKeys(envelope, ["schema_version", "configuration_sha256", "configuration"], "qualification spool configuration");
-    if (envelope.schema_version !== "qualification-spool-config-v1")
-        throw new Error("qualification spool configuration schema is unsupported");
-    const config = parseQualificationConfig(envelope.configuration);
-    const configSha = qualificationConfigDigest(config);
-    if (envelope.configuration_sha256 !== configSha)
-        throw new Error("qualification spool configuration digest mismatch");
-    const ledger = readQualificationAccounting(paths.root);
-    const accounting = validateQualificationAccountingLedger(ledger);
-    if (qualificationCanonicalJson(ledger.policy) !== qualificationCanonicalJson(config.accounting))
-        throw new Error("qualification accounting ledger policy does not match spool configuration");
-    const invocationEntries = existsSync(paths.invocations) ? readdirSync(paths.invocations, { withFileTypes: true }) : [];
-    const invalidEntry = invocationEntries.find((entry) => !entry.isDirectory());
-    if (invalidEntry)
-        throw new Error(`qualification invocations contain undeclared non-directory entry ${invalidEntry.name}`);
-    const dirs = invocationEntries.map((entry) => entry.name).sort();
-    const records = new Map();
-    for (const id of dirs) {
-        const record = readQualificationInvocation(paths.root, id);
-        if (record.configuration_sha256 !== configSha)
-            throw new Error(`qualification invocation ${id} has the wrong configuration digest`);
-        const expectedOAuthPolicy = qualificationOAuthDirectoryPolicy(config);
-        const expectedInvocationVersion = config.terminal_receipt_version === QUALIFICATION_TERMINAL_RECEIPT_VERSION_V3
-            ? record.panel ? QUALIFICATION_INVOCATION_VERSION_V4 : QUALIFICATION_INVOCATION_VERSION_V3
-            : expectedOAuthPolicy === QUALIFICATION_OAUTH_DIRECTORY_POLICY_V2
-                ? QUALIFICATION_INVOCATION_VERSION_V2
-                : QUALIFICATION_INVOCATION_VERSION;
-        if (record.schema_version !== expectedInvocationVersion ||
-            (expectedOAuthPolicy === QUALIFICATION_OAUTH_DIRECTORY_POLICY_V2 && record.oauth_directory_policy !== expectedOAuthPolicy) ||
-            (expectedOAuthPolicy !== QUALIFICATION_OAUTH_DIRECTORY_POLICY_V2 && Object.hasOwn(record, "oauth_directory_policy"))) {
-            throw new Error(`qualification invocation ${id} OAuth directory policy does not match its configuration identity`);
-        }
-        const lifecycle = readQualificationLifecycle(paths.root, id);
-        if (lifecycle.invocation_id !== id)
-            throw new Error(`qualification invocation ${id} lifecycle identity mismatch`);
-        records.set(id, record);
-    }
-    for (const event of ledger.events) {
-        const record = records.get(event.invocation_id);
-        if (!record)
-            throw new Error(`qualification accounting event references missing invocation ${event.invocation_id}`);
-        const arm = config.arms.find((candidate) => candidate.id === record.arms.selected);
-        if (!arm || arm.kind !== event.call_class || record.role !== event.role || record.counts_as_measurement !== event.counts_as_measurement) {
-            throw new Error(`qualification accounting event contradicts invocation ${event.invocation_id}`);
-        }
-    }
-    return { ok: true, configuration_sha256: configSha, invocations: records.size, accounting };
-}
-export function readQualificationSpoolConfig(spoolDir) {
-    const envelope = readCanonicalJson(qualificationSpoolPaths(spoolDir).configuration, "qualification spool configuration");
-    if (!plainObject(envelope) || !Object.hasOwn(envelope, "configuration"))
-        throw new Error("qualification spool configuration is malformed");
-    const config = parseQualificationConfig(envelope.configuration);
-    if (envelope.configuration_sha256 !== qualificationConfigDigest(config))
-        throw new Error("qualification spool configuration digest mismatch");
-    return config;
-}
-export function withQualificationFileLock(lockPath, action) {
-    const token = randomBytes(16).toString("hex");
-    const io = { read: readCanonicalJson, write: atomicWriteCanonical };
-    while (true) {
-        if (tryPublishQualificationLock(lockPath, token, io))
-            break;
-        const owner = readQualificationLockOwner(lockPath, io);
-        if (!owner)
-            continue;
-        if (qualificationLockOwnerIsLive(owner))
-            throw new Error(`qualification state is busy: lock exists at ${lockPath}`);
-        reclaimQualificationLock(lockPath, owner.token, token, io);
-    }
-    try {
-        return action();
-    }
-    finally {
-        releaseQualificationLock(lockPath, token, io);
-    }
-}
-export function atomicWriteCanonical(path, value, exclusive) {
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const text = `${qualificationCanonicalJson(value)}\n`;
-    const temporary = join(dirname(path), `.${randomBytes(12).toString("hex")}.tmp`);
-    let fd;
-    try {
-        fd = openSync(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
-        writeFileSync(fd, text, "utf8");
-        fsyncSync(fd);
-        closeSync(fd);
-        fd = undefined;
-        if (exclusive) {
-            try {
-                linkSync(temporary, path);
-            }
-            catch (error) {
-                if (error.code === "EEXIST")
-                    throw new Error(`qualification immutable record already exists: ${path}`);
-                throw error;
-            }
-            unlinkSync(temporary);
-        }
-        else {
-            renameSync(temporary, path);
-        }
-        fsyncQualificationDirectory(dirname(path));
-    }
-    finally {
-        if (fd !== undefined)
-            closeSync(fd);
-        rmSync(temporary, { force: true });
-    }
-}
-export function atomicWriteBytes(path, bytes, exclusive) {
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const temporary = join(dirname(path), `.${randomBytes(12).toString("hex")}.tmp`);
-    let fd;
-    try {
-        fd = openSync(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
-        writeFileSync(fd, bytes);
-        fsyncSync(fd);
-        closeSync(fd);
-        fd = undefined;
-        if (exclusive) {
-            linkSync(temporary, path);
-            unlinkSync(temporary);
-        }
-        else
-            renameSync(temporary, path);
-        fsyncQualificationDirectory(dirname(path));
-    }
-    finally {
-        if (fd !== undefined)
-            closeSync(fd);
-        rmSync(temporary, { force: true });
-    }
-}
-export function readCanonicalJson(path, ctx) {
-    let text;
-    let fd;
-    try {
-        fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
-        const stat = fstatSync(fd);
-        if (!stat.isFile())
-            throw new Error(`${ctx} is not a regular file`);
-        text = readFileSync(fd, "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.includes("not a regular file"))
-            throw error;
-        throw new Error(`${ctx} is missing or unreadable: ${path}`);
-    }
-    finally {
-        if (fd !== undefined)
-            closeSync(fd);
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        throw new Error(`${ctx} contains invalid JSON`);
-    }
-    if (text !== `${qualificationCanonicalJson(value)}\n`)
-        throw new Error(`${ctx} is not canonical JSON`);
-    return value;
-}
-function initializeSpoolConfiguration(path, config, digest) {
-    const envelope = { schema_version: "qualification-spool-config-v1", configuration_sha256: digest, configuration: config };
-    if (!existsSync(path)) {
-        atomicWriteCanonical(path, envelope, true);
-        return;
-    }
-    const existing = readCanonicalJson(path, "qualification spool configuration");
-    if (qualificationCanonicalJson(existing) !== qualificationCanonicalJson(envelope)) {
-        throw new Error("qualification spool is already bound to a different configuration identity");
-    }
-}
-function initializeAccounting(path, policy) {
-    if (!existsSync(path))
-        atomicWriteCanonical(path, createQualificationAccountingLedger(policy), true);
-    else {
-        const existing = readCanonicalJson(path, "qualification accounting ledger");
-        validateQualificationAccountingLedger(existing);
-        if (qualificationCanonicalJson(existing.policy) !== qualificationCanonicalJson(policy))
-            throw new Error("qualification accounting ledger policy does not match spool configuration");
-    }
-}
-function createQualificationLifecycle(invocationId, at) {
-    const base = { seq: 1, from: null, to: "prepared", terminal_status: null, at, detail: {}, previous_sha256: null };
-    const event = { ...base, event_sha256: qualificationSha256(qualificationCanonicalJson(base)) };
-    return {
-        schema_version: QUALIFICATION_LIFECYCLE_VERSION,
-        invocation_id: invocationId,
-        phase: "prepared",
-        terminal_status: null,
-        events: [event],
-        chain_head: event.event_sha256,
-    };
-}
-function validateQualificationLifecycle(value, invocationId) {
-    if (!plainObject(value))
-        throw new Error(`qualification lifecycle ${invocationId} must be an object`);
-    exactObjectKeys(value, ["schema_version", "invocation_id", "phase", "terminal_status", "events", "chain_head"], `qualification lifecycle ${invocationId}`);
-    if (value.schema_version !== QUALIFICATION_LIFECYCLE_VERSION || value.invocation_id !== invocationId)
-        throw new Error(`qualification lifecycle ${invocationId} identity/version mismatch`);
-    if (!Array.isArray(value.events) || value.events.length === 0)
-        throw new Error(`qualification lifecycle ${invocationId} has no events`);
-    let previous = null;
-    let phase = null;
-    let terminal = null;
-    const allowed = { "<root>": ["prepared"], prepared: ["launch-claimed", "terminal"], "launch-claimed": ["running", "terminal"], running: ["terminal"], terminal: [] };
-    value.events.forEach((raw, index) => {
-        if (!plainObject(raw))
-            throw new Error(`qualification lifecycle ${invocationId} event ${index + 1} must be an object`);
-        exactObjectKeys(raw, ["seq", "from", "to", "terminal_status", "at", "detail", "previous_sha256", "event_sha256"], `qualification lifecycle ${invocationId} event ${index + 1}`);
-        const event = raw;
-        if (event.seq !== index + 1 || event.from !== phase || !allowed[phase ?? "<root>"].includes(event.to))
-            throw new Error(`qualification lifecycle ${invocationId} is reordered or contradictory at event ${index + 1}`);
-        if (event.previous_sha256 !== previous)
-            throw new Error(`qualification lifecycle ${invocationId} hash chain is broken at event ${index + 1}`);
-        validTimestamp(event.at, `qualification lifecycle ${invocationId} event time`);
-        if (!plainObject(event.detail))
-            throw new Error(`qualification lifecycle ${invocationId} event detail must be an object`);
-        const { event_sha256, ...base } = event;
-        if (qualificationSha256(qualificationCanonicalJson(base)) !== event_sha256)
-            throw new Error(`qualification lifecycle ${invocationId} event digest mismatch`);
-        if (event.to === "terminal" && !isTerminalStatus(event.terminal_status))
-            throw new Error(`qualification lifecycle ${invocationId} terminal event lacks status`);
-        if (event.to !== "terminal" && event.terminal_status !== null)
-            throw new Error(`qualification lifecycle ${invocationId} nonterminal event carries status`);
-        phase = event.to;
-        terminal = event.terminal_status;
-        previous = event.event_sha256;
-    });
-    if (value.phase !== phase || value.terminal_status !== terminal || value.chain_head !== previous)
-        throw new Error(`qualification lifecycle ${invocationId} snapshot contradicts its event chain`);
-    return value;
-}
-function validateQualificationInvocationRecord(value) {
-    if (!plainObject(value))
-        throw new Error("qualification invocation record must be an object");
-    const historical = ["schema_version", "invocation_id", "measurement_identity_sha256", "continuation_authority_sha256", "continuation_authority_expires_at", "scenario", "role", "counts_as_measurement", "arms", "repetition", "requested", "authentication", "pins", "configuration_sha256", "created_at", "ceiling_policy", "execution", "expected_artifact", "invocation_sha256"];
-    if (value.schema_version === QUALIFICATION_INVOCATION_VERSION) {
-        exactObjectKeys(value, historical, `qualification invocation ${String(value.invocation_id)}`);
-    }
-    else if (value.schema_version === QUALIFICATION_INVOCATION_VERSION_V2) {
-        exactObjectKeys(value, [...historical, "oauth_directory_policy"], `qualification invocation ${String(value.invocation_id)}`);
-        if (value.oauth_directory_policy !== QUALIFICATION_OAUTH_DIRECTORY_POLICY_V2)
-            throw new Error("qualification invocation v2 OAuth directory policy is invalid");
-    }
-    else if (value.schema_version === QUALIFICATION_INVOCATION_VERSION_V3 || value.schema_version === QUALIFICATION_INVOCATION_VERSION_V4) {
-        const panelVersion = value.schema_version === QUALIFICATION_INVOCATION_VERSION_V4;
-        exactObjectKeys(value, [...historical, "oauth_directory_policy", "terminal_receipt_version", "invocation_input", "invocation_input_occurrence", "prepared_attempt", "accounting_event_sha256", ...(panelVersion ? ["panel"] : [])], `qualification invocation ${String(value.invocation_id)}`);
-        if (value.oauth_directory_policy !== QUALIFICATION_OAUTH_DIRECTORY_POLICY_V2)
-            throw new Error("qualification invocation v3 OAuth directory policy is invalid");
-        if (value.terminal_receipt_version !== QUALIFICATION_TERMINAL_RECEIPT_VERSION_V3)
-            throw new Error("qualification invocation v3 terminal receipt selection is invalid");
-        validateInvocationInputBinding(value.invocation_input);
-        validateInvocationInputOccurrence(value.invocation_input_occurrence);
-        if (value.prepared_attempt !== 0 || value.accounting_event_sha256 !== null)
-            throw new Error("qualification invocation input-bound prepared accounting identity is invalid");
-        if (panelVersion)
-            validateInvocationPanel(value.panel);
-    }
-    else {
-        throw new Error("qualification invocation version/identity is invalid");
-    }
-    assertQualificationIdentifier(value.invocation_id, "invocation_id");
-    if (!/^[a-f0-9]{64}$/.test(String(value.measurement_identity_sha256)) || !/^[a-f0-9]{64}$/.test(String(value.continuation_authority_sha256)) || !/^[a-f0-9]{64}$/.test(String(value.configuration_sha256)))
-        throw new Error(`qualification invocation ${value.invocation_id} digest identity is invalid`);
-    validTimestamp(String(value.continuation_authority_expires_at), `qualification invocation ${value.invocation_id} continuation authority expiry`);
-    validTimestamp(String(value.created_at), `qualification invocation ${value.invocation_id} creation time`);
-    assertKnownAccountingPolicy(value.ceiling_policy);
-    const { invocation_sha256: recordedDigest, ...digestInput } = value;
-    if (typeof recordedDigest !== "string" || !/^[a-f0-9]{64}$/.test(recordedDigest) || qualificationSha256(qualificationCanonicalJson(digestInput)) !== recordedDigest) {
-        throw new Error(`qualification invocation ${value.invocation_id} immutable digest mismatch`);
-    }
-}
-function assertKnownAccountingPolicy(value) {
-    const encoded = qualificationCanonicalJson(value);
-    if (encoded !== qualificationCanonicalJson(QUALIFICATION_ACCOUNTING_POLICY) && encoded !== qualificationCanonicalJson(QUALIFICATION_PANEL_ACCOUNTING_POLICY)) {
-        throw new Error("qualification accounting policy is corrupt");
-    }
-}
-function validateAccountingInput(value) {
-    if (!value || typeof value !== "object")
-        throw new Error("qualification accounting event input must be an object");
-    if (typeof value.invocation_id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value.invocation_id))
-        throw new Error("qualification accounting invocation_id is invalid");
-    if (!["holdout-author", "holdout-reviewer", "subject", "judge", "calibration", "canary"].includes(value.role))
-        throw new Error("qualification accounting role is invalid");
-    if (value.call_class !== "subject" && value.call_class !== "judge")
-        throw new Error("qualification accounting call_class is invalid");
-    if (typeof value.counts_as_measurement !== "boolean")
-        throw new Error("qualification accounting measurement flag is invalid");
-    const requiredMeasurement = value.role === "subject" || value.role === "judge";
-    if (value.counts_as_measurement !== requiredMeasurement) {
-        throw new Error(`qualification ${value.role} accounting must be ${requiredMeasurement ? "measurement" : "non-measurement"}`);
-    }
-    validTimestamp(value.launched_at, "qualification accounting launch time");
-}
-function validateInvocationInputBinding(value) {
-    if (!plainObject(value))
-        throw new Error("qualification invocation input binding must be an object");
-    exactObjectKeys(value, ["schema_version", "content_type", "bytes", "sha256"], "qualification invocation input binding");
-    if (value.schema_version !== QUALIFICATION_INVOCATION_INPUT_BINDING_VERSION)
-        throw new Error("qualification invocation input binding version is invalid");
-    if (value.content_type !== "application/json")
-        throw new Error("qualification invocation input content type is invalid");
-    if (!Number.isSafeInteger(value.bytes) || Number(value.bytes) < 1)
-        throw new Error("qualification invocation input byte count is invalid");
-    if (typeof value.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.sha256))
-        throw new Error("qualification invocation input digest is invalid");
-}
-function validateInvocationInputOccurrence(value) {
-    if (!plainObject(value))
-        throw new Error("qualification invocation input occurrence must be an object");
-    exactObjectKeys(value, ["path", "realpath", "device", "inode", "mode", "uid", "gid", "link_count", "bytes", "sha256"], "qualification invocation input occurrence");
-    for (const key of ["path", "realpath", "sha256"])
-        if (typeof value[key] !== "string")
-            throw new Error(`qualification invocation input occurrence ${key} is invalid`);
-    for (const key of ["device", "inode", "mode", "uid", "gid", "link_count", "bytes"])
-        if (!Number.isSafeInteger(value[key]))
-            throw new Error(`qualification invocation input occurrence ${key} is invalid`);
-    if (!/^[a-f0-9]{64}$/.test(String(value.sha256)) || Number(value.bytes) < 1 || Number(value.link_count) !== 1)
-        throw new Error("qualification invocation input occurrence identity is invalid");
-}
-function inspectQualificationInvocationInput(path) {
-    let fd;
-    try {
-        fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-        const stat = fstatSync(fd);
-        if (!stat.isFile())
-            throw new Error("qualification governed invocation input must be a regular file");
-        if (realpathSync(path) !== resolve(path))
-            throw new Error("qualification governed invocation input path traverses a symlink");
-        if (process.platform !== "win32" && (stat.uid !== process.getuid?.() || (stat.mode & 0o777) !== 0o600))
-            throw new Error("qualification governed invocation input must be private and owned by the qualification user");
-        if (stat.nlink !== 1)
-            throw new Error("qualification governed invocation input must have exactly one hard link");
-        const bytes = readFileSync(fd);
-        if (bytes.length < 1 || bytes.length !== stat.size)
-            throw new Error("qualification governed invocation input byte count is invalid");
-        const sha256 = qualificationSha256(bytes);
-        const binding = { schema_version: QUALIFICATION_INVOCATION_INPUT_BINDING_VERSION, content_type: "application/json", bytes: bytes.length, sha256 };
-        const occurrence = { path, realpath: realpathSync(path), device: stat.dev, inode: stat.ino, mode: stat.mode & 0o777, uid: stat.uid, gid: stat.gid, link_count: stat.nlink, bytes: bytes.length, sha256 };
-        return { binding, occurrence };
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith("qualification governed invocation input"))
-            throw error;
-        throw new Error(`qualification governed invocation input is missing, replaced, or unsafe: ${path}`);
-    }
-    finally {
-        if (fd !== undefined)
-            closeSync(fd);
-    }
-}
-function isInputBoundInvocation(invocation) {
-    return invocation.schema_version === QUALIFICATION_INVOCATION_VERSION_V3 || invocation.schema_version === QUALIFICATION_INVOCATION_VERSION_V4;
-}
-function validateInvocationPanel(value) {
-    if (!plainObject(value))
-        throw new Error("qualification invocation v4 panel binding must be an object");
-    exactObjectKeys(value, ["id", "member_ordinal", "subject_invocation_id", "subject_artifact_sha256"], "qualification invocation v4 panel binding");
-    assertQualificationIdentifier(value.id, "panel.id");
-    assertQualificationIdentifier(value.subject_invocation_id, "panel.subject_invocation_id");
-    if (![1, 2, 3].includes(Number(value.member_ordinal)) || !/^[a-f0-9]{64}$/.test(String(value.subject_artifact_sha256)))
-        throw new Error("qualification invocation v4 panel binding is invalid");
-}
-export function verifyQualificationInvocationInput(invocation) {
-    if (!isInputBoundInvocation(invocation) || !invocation.invocation_input || !invocation.invocation_input_occurrence)
-        throw new Error("qualification invocation does not carry an input binding");
-    const inspected = inspectQualificationInvocationInput(invocation.scenario.input_path);
-    if (qualificationCanonicalJson(inspected.binding) !== qualificationCanonicalJson(invocation.invocation_input))
-        throw new Error("qualification governed invocation input binding mismatch");
-    if (qualificationCanonicalJson(inspected.occurrence) !== qualificationCanonicalJson(invocation.invocation_input_occurrence))
-        throw new Error("qualification governed invocation input occurrence mismatch");
-    return inspected.binding;
-}
-function readExactSourceInput(path, expectedSha) {
-    let fd;
-    try {
-        fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-        const stat = fstatSync(fd);
-        if (!stat.isFile() || stat.nlink !== 1 || realpathSync(path) !== resolve(path))
-            throw new Error("qualification source input occurrence is unsafe");
-        const bytes = readFileSync(fd);
-        if (bytes.length !== stat.size || qualificationSha256(bytes) !== expectedSha)
-            throw new Error(`qualification input digest mismatch: expected ${expectedSha}, got ${qualificationSha256(bytes)}`);
-        return bytes;
-    }
-    catch (error) {
-        if (error instanceof Error && (error.message.includes("input digest mismatch") || error.message.includes("source input occurrence")))
-            throw error;
-        throw new Error(`qualification source input is missing, replaced, or unsafe: ${path}`);
-    }
-    finally {
-        if (fd !== undefined)
-            closeSync(fd);
-    }
-}
-function jsonContainsExactString(value, expected) {
-    if (value === expected)
-        return true;
-    if (Array.isArray(value))
-        return value.some((entry) => jsonContainsExactString(entry, expected));
-    if (plainObject(value))
-        return Object.values(value).some((entry) => jsonContainsExactString(entry, expected));
-    return false;
-}
-function assertQualificationIdentifier(value, label) {
-    if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value))
-        throw new Error(`qualification ${label} must be a bounded ASCII identifier`);
-}
-function assertRegularInput(path, expectedSha) {
-    let stat;
-    try {
-        stat = lstatSync(path);
-    }
-    catch {
-        throw new Error(`qualification input file does not exist: ${path}`);
-    }
-    if (stat.isSymbolicLink() || !stat.isFile() || realpathSync(path) !== resolve(path))
-        throw new Error(`qualification input must be a regular non-symlink file with no symlink path components: ${path}`);
-    const actual = qualificationSha256(readFileSync(path));
-    if (actual !== expectedSha)
-        throw new Error(`qualification input digest mismatch: expected ${expectedSha}, got ${actual}`);
-}
-function assertWorkingDirectory(path) {
-    let stat;
-    try {
-        stat = lstatSync(path);
-    }
-    catch {
-        throw new Error(`qualification working directory does not exist: ${path}`);
-    }
-    if (stat.isSymbolicLink() || !stat.isDirectory())
-        throw new Error(`qualification working directory must be a regular directory: ${path}`);
-}
-function assertDirectory(path, ctx) {
-    const stat = lstatSync(path);
-    if (stat.isSymbolicLink() || !stat.isDirectory())
-        throw new Error(`${ctx} must be a non-symlink directory: ${path}`);
-    if (process.platform !== "win32" && ((stat.mode & 0o077) !== 0 || stat.uid !== process.getuid?.())) {
-        throw new Error(`${ctx} must be private and owned by the qualification user: ${path}`);
-    }
-}
-function parseJsonFile(path, ctx) {
-    let text;
-    try {
-        const stat = lstatSync(path);
-        if (stat.isSymbolicLink() || !stat.isFile())
-            throw new Error(`${ctx} path is not a regular file`);
-        text = readFileSync(path, "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.includes("not a regular file"))
-            throw error;
-        throw new Error(`${ctx} is missing or unreadable: ${path}`);
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        throw new Error(`${ctx} contains invalid JSON`);
-    }
-}
-function validTimestamp(value, ctx) {
-    if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/.test(value) || !Number.isFinite(Date.parse(value)))
-        throw new Error(`${ctx} must be an RFC 3339 UTC timestamp`);
-    return value;
-}
-function isTerminalStatus(value) {
-    return ["completed", "failed", "timed-out", "aborted", "refused", "invalid-artifact"].includes(String(value));
-}
-function plainObject(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-function exactObjectKeys(value, keys, ctx) {
-    const allowed = new Set(keys);
-    const unknown = Object.keys(value).find((key) => !allowed.has(key));
-    if (unknown)
-        throw new Error(`${ctx} contains unknown field ${unknown}`);
-    const missing = keys.find((key) => !Object.hasOwn(value, key));
-    if (missing)
-        throw new Error(`${ctx} is missing field ${missing}`);
-}
-function sanitizeDetail(value) {
-    const encoded = qualificationCanonicalJson(value);
-    if (Buffer.byteLength(encoded) > 16 * 1024)
-        throw new Error("qualification lifecycle detail exceeds 16384 bytes");
-    const secretLike = Object.keys(value).find((key) => /(?:secret|token|credential|api.?key)/i.test(key));
-    if (secretLike)
-        throw new Error(`qualification lifecycle detail must not contain secret-like field ${secretLike}`);
-    return JSON.parse(encoded);
-}
-export function fsyncQualificationDirectory(path) {
-    if (process.platform === "win32")
-        return;
-    let fd;
-    try {
-        fd = openSync(path, constants.O_RDONLY);
-        fsyncSync(fd);
-    }
-    finally {
-        if (fd !== undefined)
-            closeSync(fd);
-    }
-}
-//# sourceMappingURL=qualification-store.js.map