@openprose/reactor-cradle 0.1.0-rc.1

package/dist/policy-author/index.d.ts

@@ -0,0 +1,103 @@
+import type { ContentHashV0, ReceiptV0 } from "@openprose/reactor/receipt";
+import type { ReactorAgentRequestV0, ReactorAgentResponseV0, ReactorAgentSdkAdapterV0, ReactorRegistrySnapshotV0 } from "@openprose/reactor/sdk";
+export declare const POLICY_AUTHOR_AGENT_CASSETTE_SCHEMA_V0: "openprose.reactor-cradle.policy-author-agent-cassette";
+export declare const POLICY_AUTHOR_AGENT_CASSETTE_VERSION_V0: 0;
+export interface RecordedPolicyAuthorAgentExchangeV0 {
+    readonly request: ReactorAgentRequestV0;
+    readonly request_canonical: string;
+    readonly request_hash: ContentHashV0;
+    readonly response: ReactorAgentResponseV0;
+    readonly response_canonical: string;
+    readonly response_hash: ContentHashV0;
+}
+export interface PolicyAuthorAgentCassetteV0 {
+    readonly schema: typeof POLICY_AUTHOR_AGENT_CASSETTE_SCHEMA_V0;
+    readonly v: typeof POLICY_AUTHOR_AGENT_CASSETTE_VERSION_V0;
+    readonly exchanges: readonly RecordedPolicyAuthorAgentExchangeV0[];
+}
+export interface PolicyAuthorAgentHandlerContextV0 {
+    readonly exchange_index: number;
+}
+export type PolicyAuthorAgentHandlerV0 = (request: ReactorAgentRequestV0, context: PolicyAuthorAgentHandlerContextV0) => ReactorAgentResponseV0;
+export interface RecordingPolicyAuthorAgentSdkV0 {
+    readonly adapter: ReactorAgentSdkAdapterV0;
+    readonly cassette: PolicyAuthorAgentCassetteV0;
+    readonly launch_count: number;
+}
+export interface ReplayPolicyAuthorAgentSdkV0 {
+    readonly adapter: ReactorAgentSdkAdapterV0;
+    readonly launch_count: number;
+    readonly remaining: number;
+    readonly assertConsumed: () => void;
+}
+export interface PolicyAuthorContractRevisionV0 {
+    readonly responsibility_id: string;
+    readonly revision: ContentHashV0;
+    readonly summary: string;
+    readonly no_anchor: boolean;
+}
+export type PolicyLiveObservableSourceV0 = "connector" | "receipt-log" | "kernel-backstop" | "cost-ledger" | "human-label-stream";
+export interface PolicyLiveObservableV0 {
+    readonly id: string;
+    readonly source: PolicyLiveObservableSourceV0;
+    readonly description: string;
+}
+export interface PolicyAuthorP1AuthorInputV0 {
+    readonly responsibility_id: string;
+    readonly contract_revision: ContentHashV0;
+    readonly contract_summary: string;
+    readonly contract: PolicyAuthorContractRevisionV0;
+    readonly no_anchor: boolean;
+    readonly live_observables: readonly PolicyLiveObservableV0[];
+    readonly receipt_history: readonly ReceiptV0[];
+    readonly receipts: readonly ReceiptV0[];
+    readonly agentSdk: ReactorAgentSdkAdapterV0;
+    readonly agent_sdk: ReactorAgentSdkAdapterV0;
+    readonly as_of: string;
+    readonly policy_artifact_namespace?: string;
+}
+export type AuthorPolicyArtifactV0 = (input: PolicyAuthorP1AuthorInputV0) => Promise<ReactorRegistrySnapshotV0> | ReactorRegistrySnapshotV0;
+export interface RunRecordedPolicyAuthorP1ProofInputV0 {
+    readonly authorPolicyArtifactV0: AuthorPolicyArtifactV0;
+    readonly responsibility_id: string;
+    readonly contract_revision: ContentHashV0;
+    readonly contract_summary: string;
+    readonly no_anchor: boolean;
+    readonly live_observables: readonly PolicyLiveObservableV0[];
+    readonly receipt_history: readonly ReceiptV0[];
+    readonly as_of: string;
+    readonly policy_artifact_namespace?: string;
+    readonly handler: PolicyAuthorAgentHandlerV0;
+}
+export interface PolicyAuthorP1CassetteObservationV0 {
+    readonly launch_count: number;
+    readonly history_query_index: number;
+    readonly artifact_authoring_index: number;
+    readonly history_query_request_hash: ContentHashV0;
+    readonly artifact_authoring_request_hash: ContentHashV0;
+    readonly summary_only_history_query: true;
+}
+export interface PolicyAuthorRegistryReplayEvidenceV0 {
+    readonly policy_artifact_namespace: string;
+    readonly policy_artifact_revision: string;
+    readonly policy_artifact_content_hash: ContentHashV0;
+    readonly validation_state: "validated";
+    readonly artifact_bytes_canonical: true;
+}
+export interface RecordedPolicyAuthorP1ProofV0 {
+    readonly cassette: PolicyAuthorAgentCassetteV0;
+    readonly observation: PolicyAuthorP1CassetteObservationV0;
+    readonly registry: PolicyAuthorRegistryReplayEvidenceV0;
+    readonly recorded_snapshot: ReactorRegistrySnapshotV0;
+    readonly replayed_snapshot: ReactorRegistrySnapshotV0;
+    readonly recorded_snapshot_hash: ContentHashV0;
+    readonly replayed_snapshot_hash: ContentHashV0;
+    readonly replay_launch_count: number;
+}
+export declare function createRecordingPolicyAuthorAgentSdkV0(handler: PolicyAuthorAgentHandlerV0): RecordingPolicyAuthorAgentSdkV0;
+export declare function createReplayPolicyAuthorAgentSdkV0(cassette: PolicyAuthorAgentCassetteV0): ReplayPolicyAuthorAgentSdkV0;
+export declare function runRecordedPolicyAuthorP1ProofV0(input: RunRecordedPolicyAuthorP1ProofInputV0): Promise<RecordedPolicyAuthorP1ProofV0>;
+export declare function observePolicyAuthorP1CassetteV0(cassette: PolicyAuthorAgentCassetteV0): PolicyAuthorP1CassetteObservationV0;
+export declare function assertReplayableRegistrySnapshotV0(snapshot: ReactorRegistrySnapshotV0): PolicyAuthorRegistryReplayEvidenceV0;
+export declare function clonePolicyAuthorAgentCassetteV0(cassette: PolicyAuthorAgentCassetteV0): PolicyAuthorAgentCassetteV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/policy-author/index.d.ts.map

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

package/dist/policy-author/index.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLICY_AUTHOR_AGENT_CASSETTE_VERSION_V0 = exports.POLICY_AUTHOR_AGENT_CASSETTE_SCHEMA_V0 = void 0;
+exports.createRecordingPolicyAuthorAgentSdkV0 = createRecordingPolicyAuthorAgentSdkV0;
+exports.createReplayPolicyAuthorAgentSdkV0 = createReplayPolicyAuthorAgentSdkV0;
+exports.runRecordedPolicyAuthorP1ProofV0 = runRecordedPolicyAuthorP1ProofV0;
+exports.observePolicyAuthorP1CassetteV0 = observePolicyAuthorP1CassetteV0;
+exports.assertReplayableRegistrySnapshotV0 = assertReplayableRegistrySnapshotV0;
+exports.clonePolicyAuthorAgentCassetteV0 = clonePolicyAuthorAgentCassetteV0;
+const node_crypto_1 = require("node:crypto");
+exports.POLICY_AUTHOR_AGENT_CASSETTE_SCHEMA_V0 = "openprose.reactor-cradle.policy-author-agent-cassette";
+exports.POLICY_AUTHOR_AGENT_CASSETTE_VERSION_V0 = 0;
+function createRecordingPolicyAuthorAgentSdkV0(handler) {
+    const exchanges = [];
+    const adapter = {
+        launch(request) {
+            assertPolicyAuthorRequest(request);
+            const requestSnapshot = createCanonicalSnapshot(request, "policy author agent request");
+            const response = handler(cloneFromCanonical(requestSnapshot), {
+                exchange_index: exchanges.length,
+            });
+            const responseSnapshot = createCanonicalSnapshot(response, "policy author agent response");
+            exchanges.push({
+                request: requestSnapshot.value,
+                request_canonical: requestSnapshot.canonical,
+                request_hash: requestSnapshot.hash,
+                response: responseSnapshot.value,
+                response_canonical: responseSnapshot.canonical,
+                response_hash: responseSnapshot.hash,
+            });
+            return cloneFromCanonical(responseSnapshot);
+        },
+    };
+    return {
+        adapter,
+        get cassette() {
+            return clonePolicyAuthorAgentCassetteV0({
+                schema: exports.POLICY_AUTHOR_AGENT_CASSETTE_SCHEMA_V0,
+                v: exports.POLICY_AUTHOR_AGENT_CASSETTE_VERSION_V0,
+                exchanges,
+            });
+        },
+        get launch_count() {
+            return exchanges.length;
+        },
+    };
+}
+function createReplayPolicyAuthorAgentSdkV0(cassette) {
+    const replayCassette = clonePolicyAuthorAgentCassetteV0(cassette);
+    let cursor = 0;
+    const adapter = {
+        launch(request) {
+            assertPolicyAuthorRequest(request);
+            const expected = replayCassette.exchanges[cursor];
+            if (expected === undefined) {
+                throw new Error(`policy author replay exhausted at exchange ${cursor}; cassette has ${replayCassette.exchanges.length} exchanges`);
+            }
+            const actual = createCanonicalSnapshot(request, "policy author replay request");
+            if (actual.canonical !== expected.request_canonical) {
+                throw new Error(`unexpected policy author request at exchange ${cursor}: expected ${expected.request_hash}, received ${actual.hash}`);
+            }
+            cursor += 1;
+            return cloneFromCanonical({
+                value: expected.response,
+                canonical: expected.response_canonical,
+                hash: expected.response_hash,
+            });
+        },
+    };
+    return {
+        adapter,
+        get launch_count() {
+            return cursor;
+        },
+        get remaining() {
+            return replayCassette.exchanges.length - cursor;
+        },
+        assertConsumed() {
+            if (cursor !== replayCassette.exchanges.length) {
+                throw new Error(`policy author replay stopped after ${cursor} of ${replayCassette.exchanges.length} recorded exchanges`);
+            }
+        },
+    };
+}
+async function runRecordedPolicyAuthorP1ProofV0(input) {
+    const recording = createRecordingPolicyAuthorAgentSdkV0(input.handler);
+    const recordedSnapshot = await input.authorPolicyArtifactV0(buildAuthorInput(input, recording.adapter));
+    const cassette = recording.cassette;
+    const observation = observePolicyAuthorP1CassetteV0(cassette);
+    const registry = assertReplayableRegistrySnapshotV0(recordedSnapshot);
+    const replay = createReplayPolicyAuthorAgentSdkV0(cassette);
+    const replayedSnapshot = await input.authorPolicyArtifactV0(buildAuthorInput(input, replay.adapter));
+    replay.assertConsumed();
+    const recordedSnapshotHash = hashCanonical(renderCanonical(recordedSnapshot));
+    const replayedSnapshotHash = hashCanonical(renderCanonical(replayedSnapshot));
+    if (recordedSnapshotHash !== replayedSnapshotHash) {
+        throw new Error(`policy author replay changed registry snapshot: recorded ${recordedSnapshotHash}, replayed ${replayedSnapshotHash}`);
+    }
+    assertReplayableRegistrySnapshotV0(replayedSnapshot);
+    return {
+        cassette,
+        observation,
+        registry,
+        recorded_snapshot: recordedSnapshot,
+        replayed_snapshot: replayedSnapshot,
+        recorded_snapshot_hash: recordedSnapshotHash,
+        replayed_snapshot_hash: replayedSnapshotHash,
+        replay_launch_count: replay.launch_count,
+    };
+}
+function observePolicyAuthorP1CassetteV0(cassette) {
+    const checkedCassette = clonePolicyAuthorAgentCassetteV0(cassette);
+    if (checkedCassette.exchanges.length < 2) {
+        throw new Error("policy author P1 cassette must include at least history-query and artifact-authoring exchanges");
+    }
+    const historyQueryIndex = checkedCassette.exchanges.findIndex((exchange) => exchangeMatches(exchange, ["history-query", "history_query"]));
+    if (historyQueryIndex < 0) {
+        throw new Error("policy author P1 cassette never requested receipt history");
+    }
+    const artifactAuthoringIndex = checkedCassette.exchanges.findIndex((exchange, index) => index > historyQueryIndex &&
+        exchangeMatches(exchange, [
+            "author-artifact",
+            "artifact-authoring",
+            "artifact_authoring",
+            "authored-artifact",
+            "authored_artifact",
+            "policy_artifact",
+        ]));
+    if (artifactAuthoringIndex < 0) {
+        throw new Error("policy author P1 cassette never authored an artifact after the history query");
+    }
+    const historyExchange = readExchange(checkedCassette, historyQueryIndex);
+    assertSummaryOnlyHistoryQuery(historyExchange);
+    const artifactExchange = readExchange(checkedCassette, artifactAuthoringIndex);
+    return {
+        launch_count: checkedCassette.exchanges.length,
+        history_query_index: historyQueryIndex,
+        artifact_authoring_index: artifactAuthoringIndex,
+        history_query_request_hash: historyExchange.request_hash,
+        artifact_authoring_request_hash: artifactExchange.request_hash,
+        summary_only_history_query: true,
+    };
+}
+function assertReplayableRegistrySnapshotV0(snapshot) {
+    const validationState = snapshot.policy_artifact_validation_state ?? snapshot.validation_state;
+    const validationStatus = typeof validationState === "string"
+        ? validationState
+        : isPlainRecord(validationState)
+            ? validationState["status"]
+            : undefined;
+    if (validationStatus !== "validated") {
+        throw new Error("policy author registry snapshot must be validated");
+    }
+    if (snapshot.policy_artifact_namespace.length === 0) {
+        throw new Error("policy author registry snapshot must name a policy artifact namespace");
+    }
+    if (snapshot.policy_artifact_revision.length === 0) {
+        throw new Error("policy author registry snapshot must name a policy artifact revision");
+    }
+    const bytes = snapshot.policy_artifact_bytes;
+    if (typeof bytes !== "string" || bytes.length === 0) {
+        throw new Error("policy author registry snapshot must carry canonical policy artifact bytes");
+    }
+    const parsed = parseCanonicalJson(bytes, "policy artifact bytes");
+    const rerendered = renderCanonical(parsed);
+    if (rerendered !== bytes) {
+        throw new Error("policy artifact bytes must already be canonical JSON");
+    }
+    const contentHash = hashCanonical(bytes);
+    if (snapshot.policy_artifact_content_hash !== contentHash) {
+        throw new Error(`policy artifact content hash mismatch: expected ${contentHash}, received ${snapshot.policy_artifact_content_hash ?? "undefined"}`);
+    }
+    return {
+        policy_artifact_namespace: snapshot.policy_artifact_namespace,
+        policy_artifact_revision: snapshot.policy_artifact_revision,
+        policy_artifact_content_hash: contentHash,
+        validation_state: "validated",
+        artifact_bytes_canonical: true,
+    };
+}
+function clonePolicyAuthorAgentCassetteV0(cassette) {
+    if (cassette.schema !== exports.POLICY_AUTHOR_AGENT_CASSETTE_SCHEMA_V0) {
+        throw new Error("policy author cassette schema must be openprose.reactor-cradle.policy-author-agent-cassette");
+    }
+    if (cassette.v !== exports.POLICY_AUTHOR_AGENT_CASSETTE_VERSION_V0) {
+        throw new Error("policy author cassette version must be 0");
+    }
+    if (!Array.isArray(cassette.exchanges)) {
+        throw new Error("policy author cassette exchanges must be an array");
+    }
+    return {
+        schema: exports.POLICY_AUTHOR_AGENT_CASSETTE_SCHEMA_V0,
+        v: exports.POLICY_AUTHOR_AGENT_CASSETTE_VERSION_V0,
+        exchanges: cassette.exchanges.map((exchange, index) => cloneExchange(exchange, index)),
+    };
+}
+function buildAuthorInput(input, agentSdk) {
+    const contract = {
+        responsibility_id: input.responsibility_id,
+        revision: input.contract_revision,
+        summary: input.contract_summary,
+        no_anchor: input.no_anchor,
+    };
+    const authorInput = {
+        responsibility_id: input.responsibility_id,
+        contract_revision: input.contract_revision,
+        contract_summary: input.contract_summary,
+        contract,
+        no_anchor: input.no_anchor,
+        live_observables: input.live_observables,
+        receipt_history: input.receipt_history,
+        receipts: input.receipt_history,
+        agentSdk,
+        agent_sdk: agentSdk,
+        as_of: input.as_of,
+    };
+    return input.policy_artifact_namespace === undefined
+        ? authorInput
+        : {
+            ...authorInput,
+            policy_artifact_namespace: input.policy_artifact_namespace,
+        };
+}
+function cloneExchange(exchange, index) {
+    const request = createCanonicalSnapshot(exchange.request, `policy author cassette exchange ${index} request`);
+    const response = createCanonicalSnapshot(exchange.response, `policy author cassette exchange ${index} response`);
+    assertPolicyAuthorRequest(request.value);
+    assertStoredCanonical(exchange.request_canonical, request.canonical, `policy author cassette exchange ${index} request_canonical`);
+    assertStoredHash(exchange.request_hash, request.hash, `policy author cassette exchange ${index} request_hash`);
+    assertStoredCanonical(exchange.response_canonical, response.canonical, `policy author cassette exchange ${index} response_canonical`);
+    assertStoredHash(exchange.response_hash, response.hash, `policy author cassette exchange ${index} response_hash`);
+    return {
+        request: request.value,
+        request_canonical: request.canonical,
+        request_hash: request.hash,
+        response: response.value,
+        response_canonical: response.canonical,
+        response_hash: response.hash,
+    };
+}
+function assertPolicyAuthorRequest(request) {
+    if (request.kind !== "policy-author") {
+        throw new Error("policy-author Cradle double only handles policy-author agent launches");
+    }
+}
+function assertSummaryOnlyHistoryQuery(exchange) {
+    const request = exchange.request_canonical;
+    const hasSummary = request.includes("receipt_summary") ||
+        request.includes("receipt_summaries") ||
+        request.includes("receipt_history_summary") ||
+        request.includes("history_summary");
+    if (!hasSummary) {
+        throw new Error("policy author history query must be launched from receipt summary only");
+    }
+    if (request.includes('"schema":"openprose.receipt"') ||
+        request.includes('"verdict":') ||
+        request.includes('"freshness":') ||
+        request.includes('"composition":') ||
+        request.includes('"cost":')) {
+        throw new Error("policy author history query must not receive full receipt bodies before selecting history");
+    }
+}
+function exchangeMatches(exchange, markers) {
+    const request = exchange.request_canonical;
+    const response = exchange.response_canonical;
+    return markers.some((marker) => request.includes(marker) || response.includes(marker));
+}
+function readExchange(cassette, index) {
+    const exchange = cassette.exchanges[index];
+    if (exchange === undefined) {
+        throw new Error(`expected policy author exchange ${index}`);
+    }
+    return exchange;
+}
+function createCanonicalSnapshot(value, label) {
+    try {
+        const canonical = renderCanonical(value);
+        return {
+            value: parseCanonicalJson(canonical, label),
+            canonical,
+            hash: hashCanonical(canonical),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "canonicalization failed";
+        throw new Error(`${label} must be canonical JSON: ${message}`);
+    }
+}
+function cloneFromCanonical(snapshot) {
+    return parseCanonicalJson(snapshot.canonical, "canonical snapshot");
+}
+function assertStoredCanonical(stored, actual, label) {
+    if (stored !== actual) {
+        throw new Error(`${label} does not match canonical payload`);
+    }
+}
+function assertStoredHash(stored, actual, label) {
+    if (stored !== actual) {
+        throw new Error(`${label} does not match canonical payload hash`);
+    }
+}
+function parseCanonicalJson(value, label) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "parse failed";
+        throw new Error(`${label} must be JSON: ${message}`);
+    }
+}
+function hashCanonical(canonical) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(canonical).digest("hex")}`;
+}
+function renderCanonical(value) {
+    if (value === null) {
+        return "null";
+    }
+    switch (typeof value) {
+        case "boolean":
+            return value ? "true" : "false";
+        case "number":
+            if (!Number.isFinite(value)) {
+                throw new TypeError("Cannot canonicalize non-finite numbers");
+            }
+            return JSON.stringify(value);
+        case "string":
+            return JSON.stringify(value);
+        case "object":
+            if (Array.isArray(value)) {
+                return `[${value.map((item) => renderCanonical(item)).join(",")}]`;
+            }
+            if (!isPlainRecord(value)) {
+                throw new TypeError("Cannot canonicalize non-plain objects");
+            }
+            return renderCanonicalObject(value);
+        case "undefined":
+        case "bigint":
+        case "function":
+        case "symbol":
+            throw new TypeError(`Cannot canonicalize ${typeof value}`);
+    }
+    throw new TypeError("Cannot canonicalize unknown value");
+}
+function renderCanonicalObject(value) {
+    const entries = Object.entries(value)
+        .filter(([, entryValue]) => entryValue !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries
+        .map(([key, entryValue]) => `${JSON.stringify(key)}:${renderCanonical(entryValue)}`)
+        .join(",")}}`;
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/policy-drift/index.d.ts

@@ -0,0 +1,64 @@
+import type { KernelFactValue, PredicateEvaluation } from "@openprose/reactor/kernel";
+import type { ContentHashV0, ReceiptV0 } from "@openprose/reactor/receipt";
+import type { AuthoredPolicyArtifactV0 } from "@openprose/reactor/policy";
+export declare const POLICY_DRIFT_P2_SCENARIO_SCHEMA_V0: "openprose.reactor-cradle.policy-drift-p2-scenario";
+export declare const POLICY_DRIFT_P2_SCENARIO_VERSION_V0: 0;
+export declare const POLICY_DRIFT_P2_RESPONSIBILITY_ID: "incident-channel-current-briefing";
+export declare const POLICY_DRIFT_P2_COST_FACT: "cost.fresh_tokens_per_maintained_day";
+export declare const POLICY_DRIFT_P2_OFF_LOG_FACT: "source.incident_channel.unrecorded_sentiment_score";
+export declare const POLICY_DRIFT_P2_BACKSTOP_FACT: "kernel.deep_shallow_contradiction_count_7d";
+export type PolicyDriftOutcomeV0 = "not-tripped" | "tripped" | "indeterminate";
+export type PolicyDriftFactMapV0 = Readonly<Record<string, KernelFactValue>>;
+export interface PolicyDriftEvaluatorInputV0 {
+    readonly artifact: AuthoredPolicyArtifactV0;
+    readonly receipts: readonly ReceiptV0[];
+    readonly as_of: string;
+}
+export type EvaluatePolicyDriftV0 = (input: PolicyDriftEvaluatorInputV0) => unknown;
+export interface RecordedPolicyDriftP2ScenarioV0 {
+    readonly schema: typeof POLICY_DRIFT_P2_SCENARIO_SCHEMA_V0;
+    readonly v: typeof POLICY_DRIFT_P2_SCENARIO_VERSION_V0;
+    readonly responsibility_id: string;
+    readonly contract_revision: ContentHashV0;
+    readonly as_of: string;
+    readonly receipt_history: readonly ReceiptV0[];
+    readonly cost_drift_artifact: AuthoredPolicyArtifactV0;
+    readonly off_log_artifact: AuthoredPolicyArtifactV0;
+    readonly cost_drift_artifact_bytes: string;
+    readonly cost_drift_artifact_content_hash: ContentHashV0;
+    readonly off_log_artifact_bytes: string;
+    readonly off_log_artifact_content_hash: ContentHashV0;
+}
+export interface PolicyDriftGatewayProbeV0 {
+    readonly agent_launch_count: number;
+    readonly model_gateway_invocation_count: number;
+    readonly assertNoInvocations: () => void;
+}
+export interface NormalizedPolicyDriftResultV0 {
+    readonly outcome: PolicyDriftOutcomeV0;
+    readonly facts: PolicyDriftFactMapV0;
+    readonly evidence_receipt_hashes: readonly ContentHashV0[];
+    readonly predicate: PredicateEvaluation;
+    readonly missing_fact_ids: readonly string[];
+    readonly unsupported_fact_ids: readonly string[];
+    readonly raw: unknown;
+}
+export interface RecordedPolicyDriftP2ProofV0 {
+    readonly scenario: RecordedPolicyDriftP2ScenarioV0;
+    readonly cost_drift: NormalizedPolicyDriftResultV0;
+    readonly off_log: NormalizedPolicyDriftResultV0;
+    readonly gateway_invocations: {
+        readonly agent_launch_count: 0;
+        readonly model_gateway_invocation_count: 0;
+    };
+}
+export interface RunRecordedPolicyDriftP2ProofInputV0 {
+    readonly evaluatePolicyDriftV0: EvaluatePolicyDriftV0;
+    readonly scenario?: RecordedPolicyDriftP2ScenarioV0;
+}
+export declare function createPolicyDriftGatewayProbeV0(): PolicyDriftGatewayProbeV0;
+export declare function makeRecordedPolicyDriftP2ScenarioV0(): RecordedPolicyDriftP2ScenarioV0;
+export declare function runRecordedPolicyDriftP2ProofV0(input: RunRecordedPolicyDriftP2ProofInputV0): RecordedPolicyDriftP2ProofV0;
+export declare function assertRecordedPolicyDriftP2ScenarioV0(scenario: RecordedPolicyDriftP2ScenarioV0): void;
+export declare function normalizePolicyDriftResultV0(result: unknown): NormalizedPolicyDriftResultV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/policy-drift/index.d.ts.map

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