@openprose/reactor-cradle 0.1.0-rc.1

package/dist/spikes/k2-policy-author.js

@@ -0,0 +1,503 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.K2_KNOWN_RESPONSIBILITY_ID = exports.K2_POLICY_AUTHOR_FIXTURE_VERSION_V0 = exports.K2_POLICY_AUTHOR_FIXTURE_SCHEMA_V0 = void 0;
+exports.evaluateK2PolicyAuthorFixtureV0 = evaluateK2PolicyAuthorFixtureV0;
+const { KERNEL_BACKSTOPS, KERNEL_DAY_MS, validateKernelPolicyArtifact } = loadReactorKernel();
+exports.K2_POLICY_AUTHOR_FIXTURE_SCHEMA_V0 = "openprose.reactor-cradle.k2-policy-author-fixture";
+exports.K2_POLICY_AUTHOR_FIXTURE_VERSION_V0 = 0;
+exports.K2_KNOWN_RESPONSIBILITY_ID = "incident-channel-current-briefing";
+const LIVE_OBSERVABLE_SOURCES = new Set([
+    "connector",
+    "receipt-log",
+    "kernel-backstop",
+    "cost-ledger",
+    "human-label-stream",
+]);
+function evaluateK2PolicyAuthorFixtureV0(fixture, options = {}) {
+    const failures = [];
+    const evidence = [];
+    const expectedResponsibilityId = options.expected_responsibility_id ?? exports.K2_KNOWN_RESPONSIBILITY_ID;
+    if (!isRecord(fixture)) {
+        push(failures, "$", "K2 policy-author fixture must be an object");
+        return finish({ failures, evidence, liveObservableRefs: [] });
+    }
+    validateEnvelope(fixture, failures);
+    const responsibility = fixture["responsibility"];
+    const responsibilityId = readResponsibility(responsibility, expectedResponsibilityId, failures, evidence);
+    const noAnchor = isRecord(responsibility)
+        ? readBoolean(responsibility["no_anchor"], "responsibility.no_anchor", failures)
+        : undefined;
+    const liveObservableIds = readLiveObservableIds(fixture["live_observables"], failures, evidence);
+    const authoredPolicy = fixture["authored_policy"];
+    const policy = readAuthoredPolicy(authoredPolicy, responsibilityId, noAnchor, failures, evidence);
+    if (policy !== undefined &&
+        noAnchor !== undefined &&
+        liveObservableIds.length > 0) {
+        validatePredicateLiveFacts(policy.falsification_predicate, "authored_policy.falsification_predicate", liveObservableIds, failures, evidence);
+        if (policy.backstop_divergence_predicate !== undefined) {
+            validatePredicateLiveFacts(policy.backstop_divergence_predicate, "authored_policy.backstop_divergence_predicate", liveObservableIds, failures, evidence);
+        }
+    }
+    let kernelValidation;
+    if (failures.length === 0 &&
+        policy !== undefined &&
+        noAnchor !== undefined) {
+        kernelValidation = validateKernelPolicyArtifact({
+            no_anchor: noAnchor,
+            falsification_predicate: policy.falsification_predicate,
+            live_observables: liveObservableIds,
+            ...(policy.backstop_divergence_predicate === undefined
+                ? {}
+                : {
+                    backstop_divergence_predicate: policy.backstop_divergence_predicate,
+                }),
+        });
+        if (!kernelValidation.ok) {
+            push(failures, "authored_policy", "kernel B3 validation rejected policy", {
+                errors: kernelValidation.errors,
+                live_observable_refs: kernelValidation.live_observable_refs,
+            });
+        }
+        else {
+            push(evidence, "authored_policy", "kernel B3 validation passed", {
+                live_observable_refs: kernelValidation.live_observable_refs,
+            });
+        }
+    }
+    return finish({
+        failures,
+        evidence,
+        liveObservableRefs: collectPolicyLiveObservableRefs(policy, liveObservableIds),
+        responsibilityId,
+        kernelValidation,
+    });
+}
+function validateEnvelope(fixture, failures) {
+    if (fixture["schema"] !== exports.K2_POLICY_AUTHOR_FIXTURE_SCHEMA_V0) {
+        push(failures, "schema", "fixture schema is not the K2 policy-author v0 schema", {
+            expected: exports.K2_POLICY_AUTHOR_FIXTURE_SCHEMA_V0,
+            actual: fixture["schema"] ?? null,
+        });
+    }
+    if (fixture["v"] !== exports.K2_POLICY_AUTHOR_FIXTURE_VERSION_V0) {
+        push(failures, "v", "fixture version is not K2 policy-author v0", {
+            expected: exports.K2_POLICY_AUTHOR_FIXTURE_VERSION_V0,
+            actual: fixture["v"] ?? null,
+        });
+    }
+}
+function readResponsibility(value, expectedResponsibilityId, failures, evidence) {
+    if (!isRecord(value)) {
+        push(failures, "responsibility", "fixture must name a known responsibility");
+        return undefined;
+    }
+    const id = readNonEmptyString(value["id"], "responsibility.id", failures);
+    readNonEmptyString(value["statement"], "responsibility.statement", failures);
+    if (id !== undefined && id !== expectedResponsibilityId) {
+        push(failures, "responsibility.id", "fixture targets an unknown responsibility", {
+            expected: expectedResponsibilityId,
+            actual: id,
+        });
+    }
+    if (id !== undefined) {
+        push(evidence, "responsibility.id", "recognized K2 known responsibility", {
+            id,
+        });
+    }
+    return id;
+}
+function readLiveObservableIds(value, failures, evidence) {
+    if (!Array.isArray(value) || value.length === 0) {
+        push(failures, "live_observables", "policy-author fixture must include at least one live observable");
+        return [];
+    }
+    const ids = [];
+    const seen = new Set();
+    value.forEach((observable, index) => {
+        const path = `live_observables[${index}]`;
+        if (!isRecord(observable)) {
+            push(failures, path, "live observable must be an object");
+            return;
+        }
+        const id = readNonEmptyString(observable["id"], `${path}.id`, failures);
+        const source = readNonEmptyString(observable["source"], `${path}.source`, failures);
+        readNonEmptyString(observable["description"], `${path}.description`, failures);
+        if (source !== undefined && !LIVE_OBSERVABLE_SOURCES.has(source)) {
+            push(failures, `${path}.source`, "live observable source is not replayable", {
+                allowed: [...LIVE_OBSERVABLE_SOURCES].sort(),
+                actual: source,
+            });
+        }
+        if (id !== undefined) {
+            if (seen.has(id)) {
+                push(failures, `${path}.id`, "live observable ids must be unique", {
+                    id,
+                });
+            }
+            else {
+                seen.add(id);
+                ids.push(id);
+            }
+        }
+    });
+    if (ids.length > 0) {
+        push(evidence, "live_observables", "fixture declares replayable live facts", {
+            ids: [...ids].sort(),
+        });
+    }
+    return [...ids].sort();
+}
+function readAuthoredPolicy(value, responsibilityId, noAnchor, failures, evidence) {
+    if (!isRecord(value)) {
+        push(failures, "authored_policy", "fixture must include authored policy output");
+        return undefined;
+    }
+    readNonEmptyString(value["registry_id"], "authored_policy.registry_id", failures);
+    readNonEmptyString(value["policy_revision"], "authored_policy.policy_revision", failures);
+    const policyResponsibilityId = readNonEmptyString(value["responsibility_id"], "authored_policy.responsibility_id", failures);
+    if (responsibilityId !== undefined &&
+        policyResponsibilityId !== undefined &&
+        policyResponsibilityId !== responsibilityId) {
+        push(failures, "authored_policy.responsibility_id", "authored policy targets a different responsibility than the fixture", {
+            expected: responsibilityId,
+            actual: policyResponsibilityId,
+        });
+    }
+    validateCadence(value["cadence"], noAnchor, failures, evidence);
+    validateHysteresis(value["hysteresis"], failures, evidence);
+    validateThresholds(value["thresholds"], failures, evidence);
+    const falsificationPredicate = value["falsification_predicate"];
+    const hasFalsificationPredicate = isKernelPredicateExpression(falsificationPredicate, "authored_policy.falsification_predicate", failures);
+    const divergencePredicate = value["backstop_divergence_predicate"];
+    let backstopDivergencePredicate;
+    if (divergencePredicate !== undefined &&
+        isKernelPredicateExpression(divergencePredicate, "authored_policy.backstop_divergence_predicate", failures)) {
+        backstopDivergencePredicate = divergencePredicate;
+    }
+    if (noAnchor === true && divergencePredicate === undefined) {
+        push(failures, "authored_policy.backstop_divergence_predicate", "no-anchor K2 policy must carry the B2 backstop divergence predicate");
+    }
+    if (!hasFalsificationPredicate) {
+        return undefined;
+    }
+    const policy = {
+        falsification_predicate: falsificationPredicate,
+        ...(backstopDivergencePredicate === undefined
+            ? {}
+            : { backstop_divergence_predicate: backstopDivergencePredicate }),
+    };
+    push(evidence, "authored_policy", "authored registry carries executable predicates", {
+        falsification_facts: collectPredicateFacts(policy.falsification_predicate),
+        backstop_divergence_facts: policy.backstop_divergence_predicate === undefined
+            ? []
+            : collectPredicateFacts(policy.backstop_divergence_predicate),
+    });
+    return policy;
+}
+function validateCadence(value, noAnchor, failures, evidence) {
+    if (!isRecord(value)) {
+        push(failures, "authored_policy.cadence", "policy must carry cadence shape");
+        return;
+    }
+    const shallow = readPositiveSafeInteger(value["shallow_recheck_ms"], "authored_policy.cadence.shallow_recheck_ms", failures);
+    const planAudit = readPositiveSafeInteger(value["plan_audit_ms"], "authored_policy.cadence.plan_audit_ms", failures);
+    const deep = readPositiveSafeInteger(value["deep_revalidation_ms"], "authored_policy.cadence.deep_revalidation_ms", failures);
+    if (shallow !== undefined && shallow < 5 * 60 * 1000) {
+        push(failures, "authored_policy.cadence.shallow_recheck_ms", "shallow cadence is too tight for a recorded v0.1 policy", { minimum_ms: 5 * 60 * 1000, actual: shallow });
+    }
+    if (shallow !== undefined &&
+        planAudit !== undefined &&
+        shallow > planAudit) {
+        push(failures, "authored_policy.cadence", "plan-audit cadence must not be more frequent than shallow recheck cadence", { shallow_recheck_ms: shallow, plan_audit_ms: planAudit });
+    }
+    if (planAudit !== undefined && deep !== undefined && planAudit > deep) {
+        push(failures, "authored_policy.cadence", "deep revalidation cadence must be at least as wide as plan-audit cadence", { plan_audit_ms: planAudit, deep_revalidation_ms: deep });
+    }
+    if (noAnchor === true &&
+        deep !== undefined &&
+        deep > KERNEL_BACKSTOPS.maxUnforcedDeepIntervalMs) {
+        push(failures, "authored_policy.cadence.deep_revalidation_ms", "no-anchor deep cadence cannot exceed the fixed B2 deep interval", {
+            maximum_ms: KERNEL_BACKSTOPS.maxUnforcedDeepIntervalMs,
+            actual: deep,
+        });
+    }
+    if (shallow !== undefined && planAudit !== undefined && deep !== undefined) {
+        push(evidence, "authored_policy.cadence", "cadence shape is replayable", {
+            shallow_recheck_ms: shallow,
+            plan_audit_ms: planAudit,
+            deep_revalidation_ms: deep,
+        });
+    }
+}
+function validateHysteresis(value, failures, evidence) {
+    if (!isRecord(value)) {
+        push(failures, "authored_policy.hysteresis", "policy must carry hysteresis shape");
+        return;
+    }
+    const minRecompile = readPositiveSafeInteger(value["min_recompile_interval_ms"], "authored_policy.hysteresis.min_recompile_interval_ms", failures);
+    const enter = readUnitInterval(value["enter_degraded_threshold"], "authored_policy.hysteresis.enter_degraded_threshold", failures);
+    const exit = readUnitInterval(value["exit_degraded_threshold"], "authored_policy.hysteresis.exit_degraded_threshold", failures);
+    const warmup = readPositiveSafeInteger(value["warmup_judged_activations"], "authored_policy.hysteresis.warmup_judged_activations", failures);
+    if (minRecompile !== undefined &&
+        minRecompile < KERNEL_BACKSTOPS.minRecompileIntervalMs) {
+        push(failures, "authored_policy.hysteresis.min_recompile_interval_ms", "policy hysteresis may not shorten the fixed kernel recompile floor", {
+            minimum_ms: KERNEL_BACKSTOPS.minRecompileIntervalMs,
+            actual: minRecompile,
+        });
+    }
+    if (enter !== undefined && exit !== undefined && exit >= enter) {
+        push(failures, "authored_policy.hysteresis", "exit threshold must be below enter threshold to avoid flip-flop", { enter_degraded_threshold: enter, exit_degraded_threshold: exit });
+    }
+    if (minRecompile !== undefined &&
+        enter !== undefined &&
+        exit !== undefined &&
+        warmup !== undefined) {
+        push(evidence, "authored_policy.hysteresis", "hysteresis band is sane", {
+            min_recompile_interval_ms: minRecompile,
+            enter_degraded_threshold: enter,
+            exit_degraded_threshold: exit,
+            warmup_judged_activations: warmup,
+        });
+    }
+}
+function validateThresholds(value, failures, evidence) {
+    if (!isRecord(value)) {
+        push(failures, "authored_policy.thresholds", "policy must carry threshold shape");
+        return;
+    }
+    const divergence = readPositiveFiniteNumber(value["max_calibration_divergence_multiplier"], "authored_policy.thresholds.max_calibration_divergence_multiplier", failures);
+    const precision = readUnitInterval(value["escalation_precision_floor"], "authored_policy.thresholds.escalation_precision_floor", failures);
+    const contradictionCount = readPositiveSafeInteger(value["backstop_deep_contradiction_count"], "authored_policy.thresholds.backstop_deep_contradiction_count", failures);
+    const staleBriefMinutes = readPositiveSafeInteger(value["stale_brief_minutes"], "authored_policy.thresholds.stale_brief_minutes", failures);
+    const freshTokensCeiling = readPositiveFiniteNumber(value["fresh_tokens_per_day_ceiling"], "authored_policy.thresholds.fresh_tokens_per_day_ceiling", failures);
+    if (divergence !== undefined &&
+        (divergence <= 1 ||
+            divergence > KERNEL_BACKSTOPS.maxCalibrationDivergenceMultiplier)) {
+        push(failures, "authored_policy.thresholds.max_calibration_divergence_multiplier", "calibration divergence threshold must trip before the fixed kernel ceiling", {
+            minimum_exclusive: 1,
+            maximum: KERNEL_BACKSTOPS.maxCalibrationDivergenceMultiplier,
+            actual: divergence,
+        });
+    }
+    if (staleBriefMinutes !== undefined &&
+        staleBriefMinutes * 60 * 1000 > KERNEL_DAY_MS) {
+        push(failures, "authored_policy.thresholds.stale_brief_minutes", "incident-briefing freshness threshold must fit inside a day", { maximum_minutes: KERNEL_DAY_MS / 60 / 1000, actual: staleBriefMinutes });
+    }
+    if (divergence !== undefined &&
+        precision !== undefined &&
+        contradictionCount !== undefined &&
+        staleBriefMinutes !== undefined &&
+        freshTokensCeiling !== undefined) {
+        push(evidence, "authored_policy.thresholds", "threshold shape is sane", {
+            max_calibration_divergence_multiplier: divergence,
+            escalation_precision_floor: precision,
+            backstop_deep_contradiction_count: contradictionCount,
+            stale_brief_minutes: staleBriefMinutes,
+            fresh_tokens_per_day_ceiling: freshTokensCeiling,
+        });
+    }
+}
+function validatePredicateLiveFacts(predicate, path, liveObservableIds, failures, evidence) {
+    const liveObservableSet = new Set(liveObservableIds);
+    const facts = collectPredicateFacts(predicate);
+    const offLiveFacts = facts.filter((fact) => !liveObservableSet.has(fact));
+    if (offLiveFacts.length > 0) {
+        push(failures, path, "predicate references non-live observable facts", {
+            off_live_facts: offLiveFacts,
+            live_observables: liveObservableIds,
+        });
+        return;
+    }
+    push(evidence, path, "predicate facts are all live observables", { facts });
+}
+function collectPolicyLiveObservableRefs(policy, liveObservableIds) {
+    if (policy === undefined) {
+        return [];
+    }
+    const liveObservableSet = new Set(liveObservableIds);
+    return [
+        ...new Set([
+            ...collectPredicateFacts(policy.falsification_predicate),
+            ...(policy.backstop_divergence_predicate === undefined
+                ? []
+                : collectPredicateFacts(policy.backstop_divergence_predicate)),
+        ]),
+    ]
+        .filter((fact) => liveObservableSet.has(fact))
+        .sort((left, right) => left.localeCompare(right));
+}
+function isKernelPredicateExpression(value, path, failures) {
+    if (!isRecord(value)) {
+        push(failures, path, "predicate must be an object");
+        return false;
+    }
+    const kind = value["kind"];
+    switch (kind) {
+        case "equals":
+        case "not-equals":
+            return validateFactPredicate(value, path, failures, false);
+        case "greater-than-or-equal":
+        case "less-than":
+            return validateFactPredicate(value, path, failures, true);
+        case "and":
+        case "or":
+            return validateVariadicPredicate(value, path, failures);
+        case "not":
+            return isKernelPredicateExpression(value["predicate"], `${path}.predicate`, failures);
+        default:
+            push(failures, `${path}.kind`, "predicate kind is not supported", {
+                actual: kind ?? null,
+            });
+            return false;
+    }
+}
+function validateFactPredicate(value, path, failures, numeric) {
+    let ok = true;
+    if (readNonEmptyString(value["fact"], `${path}.fact`, failures) === undefined) {
+        ok = false;
+    }
+    const expected = value["value"];
+    if (numeric) {
+        if (typeof expected !== "number" || !Number.isFinite(expected)) {
+            push(failures, `${path}.value`, "numeric predicate threshold is malformed", {
+                actual: expected ?? null,
+            });
+            ok = false;
+        }
+    }
+    else if (!isKernelFactValue(expected)) {
+        push(failures, `${path}.value`, "predicate value is malformed", {
+            actual: expected ?? null,
+        });
+        ok = false;
+    }
+    return ok;
+}
+function validateVariadicPredicate(value, path, failures) {
+    const predicates = value["predicates"];
+    if (!Array.isArray(predicates) || predicates.length === 0) {
+        push(failures, `${path}.predicates`, "variadic predicate must be non-empty");
+        return false;
+    }
+    let ok = true;
+    predicates.forEach((predicate, index) => {
+        if (!isKernelPredicateExpression(predicate, `${path}.predicates[${index}]`, failures)) {
+            ok = false;
+        }
+    });
+    return ok;
+}
+function collectPredicateFacts(expression) {
+    const facts = new Set();
+    collectFacts(expression, facts);
+    return [...facts].sort((left, right) => left.localeCompare(right));
+}
+function collectFacts(expression, facts) {
+    switch (expression.kind) {
+        case "equals":
+        case "not-equals":
+        case "greater-than-or-equal":
+        case "less-than":
+            facts.add(expression.fact);
+            return;
+        case "and":
+        case "or":
+            expression.predicates.forEach((predicate) => collectFacts(predicate, facts));
+            return;
+        case "not":
+            collectFacts(expression.predicate, facts);
+            return;
+    }
+}
+function readBoolean(value, path, failures) {
+    if (typeof value !== "boolean") {
+        push(failures, path, "field must be boolean", { actual: value ?? null });
+        return undefined;
+    }
+    return value;
+}
+function readNonEmptyString(value, path, failures) {
+    if (typeof value !== "string" || value.length === 0) {
+        push(failures, path, "field must be a non-empty string", {
+            actual: value ?? null,
+        });
+        return undefined;
+    }
+    return value;
+}
+function readPositiveSafeInteger(value, path, failures) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        push(failures, path, "field must be a positive safe integer", {
+            actual: value ?? null,
+        });
+        return undefined;
+    }
+    return value;
+}
+function readPositiveFiniteNumber(value, path, failures) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        push(failures, path, "field must be a positive finite number", {
+            actual: value ?? null,
+        });
+        return undefined;
+    }
+    return value;
+}
+function readUnitInterval(value, path, failures) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value >= 1) {
+        push(failures, path, "field must be inside the open unit interval", {
+            actual: value ?? null,
+        });
+        return undefined;
+    }
+    return value;
+}
+function isKernelFactValue(value) {
+    return (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean");
+}
+function finish(input) {
+    const ok = input.failures.length === 0;
+    const result = {
+        ok,
+        status: ok ? "pass" : "fail",
+        summary: ok
+            ? "recorded K2 policy-author output passed shape and B3 validation"
+            : "recorded K2 policy-author output failed closed",
+        live_observable_refs: Object.freeze([...input.liveObservableRefs]),
+        evidence: Object.freeze([...input.evidence]),
+        failures: Object.freeze([...input.failures]),
+        ...(input.responsibilityId === undefined
+            ? {}
+            : { responsibility_id: input.responsibilityId }),
+        ...(input.kernelValidation === undefined
+            ? {}
+            : { kernel_validation: input.kernelValidation }),
+    };
+    return result;
+}
+function push(target, path, message, observed) {
+    target.push(observed === undefined ? { path, message } : { path, message, observed });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function loadReactorKernel() {
+    try {
+        return require("@openprose/reactor/kernel");
+    }
+    catch (error) {
+        if (isMissingReactorKernelPackage(error)) {
+            return require("../../../reactor/dist/kernel");
+        }
+        throw error;
+    }
+}
+function isMissingReactorKernelPackage(error) {
+    return (isRecord(error) &&
+        error["code"] === "MODULE_NOT_FOUND" &&
+        typeof error["message"] === "string" &&
+        error["message"].includes("@openprose/reactor/kernel"));
+}

package/dist/spikes/live-refresh.d.ts

@@ -0,0 +1,150 @@
+import { type K1EnsembleSpreadFixtureV0 } from "./k1-ensemble-spread";
+export declare const OPENPROSE_DOTENV_PATH_V0: ".env";
+export declare const OPENROUTER_API_KEY_ENV_NAME_V0: "OPENROUTER_API_KEY";
+export declare const OPENROUTER_LIVE_REFRESH_PROVIDER_V0: "openrouter";
+export declare const OPENROUTER_LIVE_REFRESH_DEFAULT_MODEL_V0: "google/gemini-3.1-flash-lite-preview";
+export declare const OPENROUTER_LIVE_REFRESH_STANDING_CAP_USD_V0: 200;
+export declare const OPENROUTER_LIVE_REFRESH_GUARD_SCHEMA_V0: "openprose.reactor-cradle.openrouter-live-refresh-guard";
+export declare const OPENROUTER_LIVE_REFRESH_GUARD_VERSION_V0: 0;
+export declare const OPENROUTER_K1_LIVE_RECORDING_SCHEMA_V0: "openprose.reactor-cradle.k1-live-recording";
+export declare const OPENROUTER_K1_LIVE_RECORDING_VERSION_V0: 0;
+export declare const OPENROUTER_K1_LIVE_CHAT_COMPLETIONS_URL_V0: "https://openrouter.ai/api/v1/chat/completions";
+export declare const OPENROUTER_K1_LIVE_RECORDING_MODELS_V0: readonly [{
+    readonly provider: "google";
+    readonly model: "google/gemini-3.1-flash-lite-preview";
+    readonly family: "gemini";
+    readonly size_class: "small";
+    readonly prompt_cost_per_token_usd: 2.5e-7;
+    readonly completion_cost_per_token_usd: 0.0000015;
+    readonly max_output_tokens: 180;
+    readonly request_cap_usd: 0.25;
+}, {
+    readonly provider: "mistralai";
+    readonly model: "mistralai/mistral-small-3.2-24b-instruct";
+    readonly family: "mistral";
+    readonly size_class: "small";
+    readonly prompt_cost_per_token_usd: 7.5e-8;
+    readonly completion_cost_per_token_usd: 2e-7;
+    readonly max_output_tokens: 180;
+    readonly request_cap_usd: 0.25;
+}, {
+    readonly provider: "qwen";
+    readonly model: "qwen/qwen-2.5-72b-instruct";
+    readonly family: "qwen";
+    readonly size_class: "large";
+    readonly prompt_cost_per_token_usd: 3.6e-7;
+    readonly completion_cost_per_token_usd: 4e-7;
+    readonly max_output_tokens: 180;
+    readonly request_cap_usd: 0.25;
+}];
+export type OpenRouterLiveRefreshModelV0 = typeof OPENROUTER_LIVE_REFRESH_DEFAULT_MODEL_V0;
+export type OpenRouterLiveRefreshEnvReaderV0 = (path: string) => string;
+export interface OpenRouterLiveRefreshAccountingV0 {
+    readonly currency: "USD";
+    readonly cap_usd: number;
+    readonly spent_usd: number;
+    readonly request_cap_usd: number;
+    readonly account_ref: string;
+    readonly ledger_ref: string;
+}
+export interface PrepareOpenRouterLiveRefreshInputV0 {
+    readonly allow_live?: boolean;
+    readonly accounting?: OpenRouterLiveRefreshAccountingV0;
+    readonly env_path?: string;
+    readonly model?: string;
+    readonly readEnvFile?: OpenRouterLiveRefreshEnvReaderV0;
+}
+export interface OpenRouterLiveRefreshDisabledV0 {
+    readonly schema: typeof OPENROUTER_LIVE_REFRESH_GUARD_SCHEMA_V0;
+    readonly v: typeof OPENROUTER_LIVE_REFRESH_GUARD_VERSION_V0;
+    readonly status: "disabled";
+    readonly provider: typeof OPENROUTER_LIVE_REFRESH_PROVIDER_V0;
+    readonly reason: "live-opt-in-required";
+}
+export interface OpenRouterLiveRefreshReadyAccountingV0 {
+    readonly currency: "USD";
+    readonly cap_usd: number;
+    readonly spent_usd: number;
+    readonly request_cap_usd: number;
+    readonly remaining_usd: number;
+    readonly remaining_after_request_usd: number;
+    readonly account_ref: string;
+    readonly ledger_ref: string;
+    readonly standing_cap_usd: typeof OPENROUTER_LIVE_REFRESH_STANDING_CAP_USD_V0;
+}
+export interface OpenRouterLiveRefreshReadyV0 {
+    readonly schema: typeof OPENROUTER_LIVE_REFRESH_GUARD_SCHEMA_V0;
+    readonly v: typeof OPENROUTER_LIVE_REFRESH_GUARD_VERSION_V0;
+    readonly status: "ready";
+    readonly provider: typeof OPENROUTER_LIVE_REFRESH_PROVIDER_V0;
+    readonly env_path: string;
+    readonly env_key_name: typeof OPENROUTER_API_KEY_ENV_NAME_V0;
+    readonly api_key_present: true;
+    readonly model: OpenRouterLiveRefreshModelV0;
+    readonly accounting: OpenRouterLiveRefreshReadyAccountingV0;
+}
+export type OpenRouterLiveRefreshGuardResultV0 = OpenRouterLiveRefreshDisabledV0 | OpenRouterLiveRefreshReadyV0;
+export type OpenRouterLiveRefreshInvokerV0<T> = (ready: OpenRouterLiveRefreshReadyV0) => T;
+export interface OpenRouterK1LiveModelSpecV0 {
+    readonly provider: string;
+    readonly model: string;
+    readonly family: string;
+    readonly size_class: "small" | "medium" | "large";
+    readonly prompt_cost_per_token_usd: number;
+    readonly completion_cost_per_token_usd: number;
+    readonly max_output_tokens: number;
+    readonly request_cap_usd: number;
+}
+export interface RecordOpenRouterK1LiveFixtureInputV0 extends PrepareOpenRouterLiveRefreshInputV0 {
+    readonly fetch?: typeof fetch;
+    readonly models?: readonly OpenRouterK1LiveModelSpecV0[];
+    readonly now?: () => Date;
+}
+export interface OpenRouterK1LiveOutputRecordingV0 {
+    readonly output_id: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly request_id: string;
+    readonly response_id: string;
+    readonly latency_ms: number;
+    readonly finish_reason: string;
+    readonly usage: Readonly<Record<string, unknown>>;
+    readonly spend_usd: number;
+    readonly spend_source: "openrouter-usage-cost" | "pricing-estimate-from-token-usage";
+}
+export interface OpenRouterK1LiveRecordingBlockV0 {
+    readonly schema: typeof OPENROUTER_K1_LIVE_RECORDING_SCHEMA_V0;
+    readonly v: typeof OPENROUTER_K1_LIVE_RECORDING_VERSION_V0;
+    readonly provider: typeof OPENROUTER_LIVE_REFRESH_PROVIDER_V0;
+    readonly chat_completions_url: typeof OPENROUTER_K1_LIVE_CHAT_COMPLETIONS_URL_V0;
+    readonly started_at: string;
+    readonly completed_at: string;
+    readonly cap_usd: number;
+    readonly request_cap_usd: number;
+    readonly spend_usd: number;
+    readonly currency: "USD";
+    readonly model_count: number;
+    readonly request_count: number;
+    readonly model_specs: readonly OpenRouterK1LiveModelSpecV0[];
+    readonly outputs: readonly OpenRouterK1LiveOutputRecordingV0[];
+}
+export interface OpenRouterK1LiveRecordedFixtureV0 extends K1EnsembleSpreadFixtureV0 {
+    readonly recording: OpenRouterK1LiveRecordingBlockV0;
+}
+export interface OpenRouterLiveRefreshSkippedRunV0 {
+    readonly status: "disabled";
+    readonly invoked: false;
+    readonly guard: OpenRouterLiveRefreshDisabledV0;
+}
+export interface OpenRouterLiveRefreshInvokedRunV0<T> {
+    readonly status: "ready";
+    readonly invoked: true;
+    readonly guard: OpenRouterLiveRefreshReadyV0;
+    readonly result: T;
+}
+export type OpenRouterLiveRefreshRunResultV0<T> = OpenRouterLiveRefreshSkippedRunV0 | OpenRouterLiveRefreshInvokedRunV0<T>;
+export declare function prepareOpenRouterLiveRefreshV0(input?: PrepareOpenRouterLiveRefreshInputV0): OpenRouterLiveRefreshGuardResultV0;
+export declare function runOpenRouterLiveRefreshV0<T>(input: PrepareOpenRouterLiveRefreshInputV0, invokeLiveRefresh: OpenRouterLiveRefreshInvokerV0<T>): OpenRouterLiveRefreshRunResultV0<T>;
+export declare function recordOpenRouterK1LiveFixtureV0(input: RecordOpenRouterK1LiveFixtureInputV0): Promise<OpenRouterK1LiveRecordedFixtureV0>;
+export declare function hasOpenRouterApiKeyInDotenvV0(dotenvText: string): boolean;
+//# sourceMappingURL=live-refresh.d.ts.map

package/dist/spikes/live-refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-refresh.d.ts","sourceRoot":"","sources":["../../src/spikes/live-refresh.ts"],"names":[],"mappings":"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"}