@openprose/reactor-cradle 0.1.0-rc.1

package/dist/release-parity/index.js

@@ -0,0 +1,1035 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRecordedR6ReleaseParityEvalResultV0 = exports.R6_RELEASE_PARITY_DEFERRED_CASE_IDS_V0 = exports.R6_RELEASE_PARITY_CASE_IDS_V0 = exports.R6_RELEASE_PARITY_PROOF_VERSION_V0 = exports.R6_RELEASE_PARITY_PROOF_SCHEMA_V0 = exports.R6_RELEASE_PARITY_SUITE_VERSION_V0 = exports.R6_RELEASE_PARITY_SUITE_SCHEMA_V0 = void 0;
+exports.makeRecordedR6ReleaseParitySuiteV0 = makeRecordedR6ReleaseParitySuiteV0;
+exports.makeR6ReleaseParityReplayInputV0 = makeR6ReleaseParityReplayInputV0;
+exports.runRecordedR6ReleaseParityProofV0 = runRecordedR6ReleaseParityProofV0;
+exports.buildR6ReleaseParityEvalResultV0 = buildR6ReleaseParityEvalResultV0;
+exports.assertRecordedR6ReleaseParitySuiteV0 = assertRecordedR6ReleaseParitySuiteV0;
+exports.assertR6ReleaseParityCaseV0 = assertR6ReleaseParityCaseV0;
+const node_crypto_1 = require("node:crypto");
+const eval_1 = require("../eval");
+const parity_1 = require("../replay/parity");
+const { dependencyReceiptPinFromVerifiedReceiptV0, evaluateTransitiveFreshnessV0, verifyUpstreamReceiptDependencyPinV0, } = loadReactorComposition();
+const { evaluateForecastScheduleV0 } = loadReactorForecast();
+const { computeMemoKeyV0, createMemoHitReceiptV0 } = loadReactorMemo();
+const { canonicalizeForReceiptV0, createReceiptV0, hashCanonicalReceiptV0, verifyReceiptV0, } = loadReactorReceipt();
+exports.R6_RELEASE_PARITY_SUITE_SCHEMA_V0 = "openprose.reactor-cradle.r6-release-parity-suite";
+exports.R6_RELEASE_PARITY_SUITE_VERSION_V0 = 0;
+exports.R6_RELEASE_PARITY_PROOF_SCHEMA_V0 = "openprose.reactor-cradle.r6-release-parity-proof";
+exports.R6_RELEASE_PARITY_PROOF_VERSION_V0 = 0;
+exports.R6_RELEASE_PARITY_CASE_IDS_V0 = [
+    "healthy-quiet",
+    "drifting-schedules-fulfillment",
+    "blocked-human-review",
+    "forecast-pulls-judge-earlier",
+    "hysteresis-prevents-flip-flop",
+    "duplicate-event-idempotency",
+    "stale-status-fencing",
+    "contract-revision-fencing",
+    "policy-recompile-byte-identical-registry",
+    "memoized-verdict-zero-fresh-tokens",
+];
+exports.R6_RELEASE_PARITY_DEFERRED_CASE_IDS_V0 = [
+    "down-after-budget-exhaustion",
+];
+const SUITE_ID = "v0.4-r6-release-parity-fixture-floor";
+const GENERATED_AT = "2026-05-18T22:30:00.000Z";
+const INITIAL_INSTANT = "2026-05-18T12:00:00.000Z";
+const FINAL_INSTANT = "2026-05-19T12:00:00.000Z";
+const CONTRACT_REVISION = hashText("r6-release-parity-contract-v0");
+const ATTACKER_CONTRACT_REVISION = hashText("r6-release-parity-attacker-contract-v0");
+const POLICY_ARTIFACT_BYTES = canonicalizeForReceiptV0({
+    schema: "openprose.reactor.policy-artifact",
+    v: 0,
+    name: "r6.release-parity.recorded",
+    cadence: "recorded-fixture-floor",
+});
+const POLICY_ARTIFACT_CONTENT_HASH = hashCanonicalReceiptV0(POLICY_ARTIFACT_BYTES);
+const TRANSITIVE_FRESHNESS_POLICY_REF = "policy://cradle.r6.release-parity@policy-v0#transitive-freshness-v0";
+const MEMO_NAMESPACE = {
+    policy_artifact_namespace: "cradle.r6.release-parity",
+    policy_artifact_revision: "policy-v0",
+};
+function makeRecordedR6ReleaseParitySuiteV0() {
+    const cases = Object.freeze([
+        makeHealthyQuietCase(),
+        makeDriftingSchedulesFulfillmentCase(),
+        makeBlockedHumanReviewCase(),
+        makeForecastPullsJudgeEarlierCase(),
+        makeHysteresisPreventsFlipFlopCase(),
+        makeDuplicateEventIdempotencyCase(),
+        makeStaleStatusFencingCase(),
+        makeContractRevisionFencingCase(),
+        makePolicyRecompileByteIdenticalRegistryCase(),
+        makeMemoizedVerdictZeroFreshTokensCase(),
+    ]);
+    const registry = makeRegistrySnapshot();
+    return Object.freeze({
+        schema: exports.R6_RELEASE_PARITY_SUITE_SCHEMA_V0,
+        v: exports.R6_RELEASE_PARITY_SUITE_VERSION_V0,
+        suite_id: SUITE_ID,
+        generated_at: GENERATED_AT,
+        as_of: FINAL_INSTANT,
+        initial_instant: INITIAL_INSTANT,
+        final_instant: FINAL_INSTANT,
+        world_profile: "recorded-release-parity",
+        cassette_path: "recorded://openprose/reactor-cradle/r6-release-parity-v0",
+        registry,
+        registry_content_hash: hashCanonicalValue(registry),
+        cases,
+        deferred_cases: Object.freeze([
+            Object.freeze({
+                case_id: "down-after-budget-exhaustion",
+                reason: "Current Reactor/Cradle APIs do not yet expose a typed retry-budget or pressure-dispatch primitive, so R6 records the gap instead of synthesizing a false down proof.",
+                missing_primitives: Object.freeze([
+                    "typed retry/budget ledger",
+                    "pressure-dispatch claim with exhausted-budget receipt evidence",
+                ]),
+                boundary: "not-represented-in-r6",
+            }),
+        ]),
+    });
+}
+function makeR6ReleaseParityReplayInputV0(suite = makeRecordedR6ReleaseParitySuiteV0()) {
+    assertRecordedR6ReleaseParitySuiteV0(suite);
+    return {
+        scenario_id: suite.suite_id,
+        world_profile: suite.world_profile,
+        cassette_path: suite.cassette_path,
+        initial_instant: suite.initial_instant,
+        final_instant: suite.final_instant,
+        trace: suite.cases.map((item) => ({
+            case_id: item.case_id,
+            trace: item.trace,
+        })),
+        receipt_log: {
+            entries: suite.cases.flatMap((item) => item.receipts),
+        },
+        expected_relationships: suite.cases.map((item) => ({
+            case_id: item.case_id,
+            relationships: item.expected_relationships,
+        })),
+        decisions: {
+            entries: suite.cases.flatMap((item) => item.decisions),
+            deferred_cases: suite.deferred_cases,
+        },
+        registry: suite.registry,
+    };
+}
+function runRecordedR6ReleaseParityProofV0(suite = makeRecordedR6ReleaseParitySuiteV0()) {
+    assertRecordedR6ReleaseParitySuiteV0(suite);
+    const replayInput = makeR6ReleaseParityReplayInputV0(suite);
+    const assertions = Object.freeze(suite.cases.map(assertR6ReleaseParityCaseV0));
+    const parity = (0, parity_1.runReplayParityMatrixV0)({
+        baseline: replayInput,
+        runAdapter() {
+            return makeR6ReleaseParityReplayInputV0(suite);
+        },
+    });
+    if (!parity.ok) {
+        throw new Error("R6 release parity fixture floor must be byte-identical");
+    }
+    const failedAssertion = assertions.find((item) => item.status === "fail");
+    if (failedAssertion !== undefined) {
+        throw new Error(`R6 release parity assertion failed: ${failedAssertion.summary}`);
+    }
+    return Object.freeze({
+        schema: exports.R6_RELEASE_PARITY_PROOF_SCHEMA_V0,
+        v: exports.R6_RELEASE_PARITY_PROOF_VERSION_V0,
+        suite,
+        replay_snapshot: (0, parity_1.snapshotReplayComparableOutputV0)(replayInput),
+        parity,
+        assertions,
+    });
+}
+function buildR6ReleaseParityEvalResultV0(proof = runRecordedR6ReleaseParityProofV0()) {
+    return (0, eval_1.buildCradleEvalResultV0)({
+        suite_id: proof.suite.suite_id,
+        generated_at: proof.suite.generated_at,
+        as_of: proof.suite.as_of,
+        model_matrix: {
+            status: "not-run",
+            reason: "R6 release parity uses deterministic recorded Cradle fixtures; live provider/model matrix remains deferred.",
+        },
+        cases: proof.suite.cases.map((item, index) => {
+            const assertion = proof.assertions[index];
+            if (assertion === undefined) {
+                throw new Error(`missing release parity assertion for ${item.case_id}`);
+            }
+            const base = {
+                case_id: item.case_id,
+                scenario_id: proof.suite.suite_id,
+                assertions: [assertion],
+                evidence_hashes: item.evidence_hashes,
+            };
+            return index === 0 ? { ...base, replay: proof.parity } : base;
+        }),
+    });
+}
+exports.buildRecordedR6ReleaseParityEvalResultV0 = buildR6ReleaseParityEvalResultV0;
+function assertRecordedR6ReleaseParitySuiteV0(suite) {
+    if (suite.schema !== exports.R6_RELEASE_PARITY_SUITE_SCHEMA_V0) {
+        throw new Error("R6 release parity suite schema is malformed");
+    }
+    if (suite.v !== exports.R6_RELEASE_PARITY_SUITE_VERSION_V0) {
+        throw new Error("R6 release parity suite version must be 0");
+    }
+    assertRequiredCaseCoverage(suite.cases);
+    if (!suite.deferred_cases.some((item) => item.case_id === "down-after-budget-exhaustion")) {
+        throw new Error("R6 suite must explicitly defer down-after-budget-exhaustion");
+    }
+    for (const item of suite.cases) {
+        assertR6ReleaseParityCaseV0(item);
+    }
+}
+function assertR6ReleaseParityCaseV0(item) {
+    const failures = [];
+    const receiptHashes = new Set(item.receipts.map((receipt) => receipt.content_hash));
+    if (item.decisions.length === 0) {
+        failures.push({
+            path: `${item.case_id}.decisions`,
+            message: "release-parity case must include at least one recorded decision",
+        });
+    }
+    if (item.trace.length === 0) {
+        failures.push({
+            path: `${item.case_id}.trace`,
+            message: "release-parity case must include recorded trace evidence",
+        });
+    }
+    for (const [index, receipt] of item.receipts.entries()) {
+        const verification = verifyReceiptV0(receipt);
+        if (!verification.ok) {
+            failures.push({
+                path: `${item.case_id}.receipts[${index}]`,
+                message: "recorded receipt must verify",
+                observed: verification.errors,
+            });
+        }
+        else if (verification.content_hash !== receipt.content_hash) {
+            failures.push({
+                path: `${item.case_id}.receipts[${index}].content_hash`,
+                message: "recorded receipt content hash must match canonical hash",
+                observed: {
+                    expected: verification.content_hash,
+                    actual: receipt.content_hash,
+                },
+            });
+        }
+    }
+    for (const [index, decision] of item.decisions.entries()) {
+        if (decision.case_id !== item.case_id) {
+            failures.push({
+                path: `${item.case_id}.decisions[${index}].case_id`,
+                message: "decision must be scoped to its release-parity case",
+                observed: decision.case_id,
+            });
+        }
+        for (const receiptHash of decision.receipt_hashes) {
+            if (!receiptHashes.has(receiptHash)) {
+                failures.push({
+                    path: `${item.case_id}.decisions[${index}].receipt_hashes`,
+                    message: "decision referenced a receipt outside the case",
+                    observed: receiptHash,
+                });
+            }
+        }
+        const tokenSummary = sumTokens(item.receipts);
+        if (decision.token_summary.fresh !== tokenSummary.fresh ||
+            decision.token_summary.reused !== tokenSummary.reused) {
+            failures.push({
+                path: `${item.case_id}.decisions[${index}].token_summary`,
+                message: "decision token summary must match recorded receipts",
+                observed: {
+                    expected: tokenSummary,
+                    actual: decision.token_summary,
+                },
+            });
+        }
+    }
+    if (failures.length > 0) {
+        return releaseParityResult("fail", `${item.case_id} release-parity fixture is malformed`, failures);
+    }
+    return releaseParityResult("pass", `${item.case_id} is represented by deterministic recorded ${item.represented_by}`, [
+        {
+            path: item.case_id,
+            message: "checked release-parity recorded fixture",
+            observed: {
+                receipts: item.receipts.length,
+                decisions: item.decisions.length,
+                trace_entries: item.trace.length,
+                relationships: item.expected_relationships,
+            },
+        },
+    ]);
+}
+function makeHealthyQuietCase() {
+    const evidence = hashText("r6 healthy quiet incident feed unchanged");
+    const receipt = makeReceipt({
+        case_id: "healthy-quiet",
+        memo_key: "r6:healthy-quiet:bootstrap",
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T12:00:00.000Z",
+        next_forecast_recheck: "2026-05-18T18:00:00.000Z",
+        event_cause: "real-input",
+        status: "up",
+        tokens: { fresh: 13, reused: 0 },
+        tags: ["r6", "healthy-quiet"],
+    });
+    return makeCase({
+        case_id: "healthy-quiet",
+        title: "Healthy quiet path keeps the responsibility up",
+        represented_by: "up receipt and no-op decision",
+        receipts: [receipt],
+        decisions: [
+            makeDecision({
+                case_id: "healthy-quiet",
+                as_of: receipt.core.as_of,
+                outcome: "kept-up",
+                reason: "quiet source evidence preserved the up verdict",
+                receipts: [receipt],
+                evidence_hashes: [evidence],
+                guardrails: ["receipt-verification", "no-live-gateway"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: receipt.core.as_of,
+                event: "source-read",
+                observed: { source: "incident-feed", status: "quiet" },
+            },
+        ],
+        expected_relationships: ["healthy-quiet-up"],
+        notes: ["baseline release candidate path remains quiet and deterministic"],
+    });
+}
+function makeDriftingSchedulesFulfillmentCase() {
+    const evidence = hashText("r6 drifting schedule reached fulfillment");
+    const drifting = makeReceipt({
+        case_id: "drifting-schedules-fulfillment",
+        memo_key: "r6:drifting:schedule",
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T12:10:00.000Z",
+        next_forecast_recheck: "2026-05-18T12:30:00.000Z",
+        event_cause: "real-input",
+        status: "drifting",
+        tokens: { fresh: 8, reused: 0 },
+        tags: ["r6", "drifting", "schedule"],
+    });
+    const fulfilled = makeReceipt({
+        case_id: "drifting-schedules-fulfillment",
+        memo_key: "r6:drifting:fulfilled",
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T12:30:00.000Z",
+        next_forecast_recheck: "2026-05-18T18:00:00.000Z",
+        event_cause: "forecast-recheck",
+        recheck_kind: "evidence-age",
+        role: "fulfill",
+        status: "up",
+        tokens: { fresh: 0, reused: 8 },
+        tags: ["r6", "drifting", "fulfilled"],
+    });
+    return makeCase({
+        case_id: "drifting-schedules-fulfillment",
+        title: "Drifting schedules are fulfilled by recorded decision evidence",
+        represented_by: "drifting then fulfilled receipts",
+        receipts: [drifting, fulfilled],
+        decisions: [
+            makeDecision({
+                case_id: "drifting-schedules-fulfillment",
+                as_of: fulfilled.core.as_of,
+                outcome: "fulfilled-scheduled-work",
+                reason: "scheduled fulfillment consumed the drifting receipt and returned up",
+                receipts: [drifting, fulfilled],
+                evidence_hashes: [evidence],
+                guardrails: ["receipt-log-order", "forecast-schedule"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: drifting.core.as_of,
+                event: "schedule-opened",
+                observed: { status: "drifting" },
+            },
+            {
+                as_of: fulfilled.core.as_of,
+                event: "schedule-fulfilled",
+                observed: { status: "up", fresh_tokens: 0 },
+            },
+        ],
+        expected_relationships: ["drift-has-fulfillment-decision"],
+        notes: ["represented as decision evidence only; no live fulfillment side effect"],
+    });
+}
+function makeBlockedHumanReviewCase() {
+    const evidence = hashText("r6 blocked human review evidence");
+    const receipt = makeReceipt({
+        case_id: "blocked-human-review",
+        memo_key: "r6:blocked:human-review",
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T12:20:00.000Z",
+        next_forecast_recheck: "2026-05-18T12:20:00.000Z",
+        event_cause: "escalation",
+        status: "blocked",
+        blocked: {
+            reason: "human review required before responsibility can continue",
+            fix_target: "operator-review",
+            interrupt_cause: "needs-judgment",
+        },
+        tokens: { fresh: 0, reused: 0 },
+        tags: ["r6", "blocked", "human-review"],
+    });
+    return makeCase({
+        case_id: "blocked-human-review",
+        title: "Blocked requests expose human-review escalation",
+        represented_by: "blocked safety receipt",
+        receipts: [receipt],
+        decisions: [
+            makeDecision({
+                case_id: "blocked-human-review",
+                as_of: receipt.core.as_of,
+                outcome: "blocked-for-human-review",
+                reason: receipt.verdict.blocked?.reason ?? "blocked",
+                receipts: [receipt],
+                evidence_hashes: [evidence],
+                guardrails: ["interrupt-cause", "non-droppable-blocked-receipt"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: receipt.core.as_of,
+                event: "manual-review-required",
+                observed: {
+                    interrupt_cause: receipt.verdict.blocked?.interrupt_cause ?? null,
+                },
+            },
+        ],
+        expected_relationships: ["blocked-human-review-is-non-droppable"],
+        notes: ["no private review rationale is embedded in the fixture"],
+    });
+}
+function makeForecastPullsJudgeEarlierCase() {
+    const evidence = hashText("r6 forecast schedule synthetic evidence");
+    const schedule = evaluateForecastScheduleV0({
+        as_of: "2026-05-18T12:10:00.000Z",
+        real_input_observed: true,
+        schedule: {
+            responsibility_id: "r6.forecast-pulls-judge-earlier",
+            contract_revision: CONTRACT_REVISION,
+            memo_key: "r6:forecast:pull-earlier",
+            evidence_input_ids: [evidence],
+            next_evidence_recheck: "2026-05-18T12:05:00.000Z",
+            next_plan_recheck: "2026-05-18T18:00:00.000Z",
+        },
+    });
+    if (schedule.outcome !== "manufacture-recheck") {
+        throw new Error("forecast pull fixture must manufacture a recheck receipt");
+    }
+    return makeCase({
+        case_id: "forecast-pulls-judge-earlier",
+        title: "Forecast schedule pulls judge earlier than the normal plan audit",
+        represented_by: "forecast manufactured recheck receipt",
+        receipts: schedule.receipts,
+        decisions: [
+            makeDecision({
+                case_id: "forecast-pulls-judge-earlier",
+                as_of: "2026-05-18T12:10:00.000Z",
+                outcome: schedule.reason,
+                reason: "evidence-age forecast clock crossed before plan-age audit",
+                receipts: schedule.receipts,
+                evidence_hashes: [evidence],
+                guardrails: ["forecast-clock", "zero-fresh-synthetic-recheck"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: "2026-05-18T12:10:00.000Z",
+                event: "forecast-clock-crossed",
+                observed: {
+                    due_rechecks: schedule.due_rechecks,
+                    token_bearing_receipts: schedule.token_bearing_receipts.length,
+                },
+            },
+        ],
+        expected_relationships: ["forecast-can-pull-judge-earlier"],
+        notes: ["forecast recheck receipt is blocked until a judge acts"],
+    });
+}
+function makeHysteresisPreventsFlipFlopCase() {
+    const evidence = hashText("r6 hysteresis noisy verdict band");
+    const noisyDrift = makeReceipt({
+        case_id: "hysteresis-prevents-flip-flop",
+        memo_key: "r6:hysteresis:noisy-drift",
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T12:25:00.000Z",
+        next_forecast_recheck: "2026-05-18T13:25:00.000Z",
+        event_cause: "forecast-recheck",
+        recheck_kind: "plan-age",
+        status: "drifting",
+        tokens: { fresh: 0, reused: 17 },
+        tags: ["r6", "hysteresis", "noisy-verdict"],
+    });
+    const heldCurrent = makeReceipt({
+        case_id: "hysteresis-prevents-flip-flop",
+        memo_key: "r6:hysteresis:held-current",
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T12:40:00.000Z",
+        next_forecast_recheck: "2026-05-18T13:25:00.000Z",
+        event_cause: "forecast-recheck",
+        recheck_kind: "plan-age",
+        status: "up",
+        tokens: { fresh: 0, reused: 17 },
+        tags: ["r6", "hysteresis", "held-current"],
+    });
+    return makeCase({
+        case_id: "hysteresis-prevents-flip-flop",
+        title: "Hysteresis prevents noisy verdict flip-flop",
+        represented_by: "noisy verdict receipts and held-current decision",
+        receipts: [noisyDrift, heldCurrent],
+        decisions: [
+            makeDecision({
+                case_id: "hysteresis-prevents-flip-flop",
+                as_of: heldCurrent.core.as_of,
+                outcome: "held-current-policy",
+                reason: "noisy drifting verdict stayed inside the fixed recompile interval and activation band",
+                receipts: [noisyDrift, heldCurrent],
+                evidence_hashes: [evidence],
+                guardrails: ["min-recompile-interval", "judged-activation-band"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: noisyDrift.core.as_of,
+                event: "noisy-drift-observed",
+                observed: { status: "drifting", confidence: 0.51 },
+            },
+            {
+                as_of: heldCurrent.core.as_of,
+                event: "policy-held-current",
+                observed: { status: "up", policy_revision_changed: false },
+            },
+        ],
+        expected_relationships: ["hysteresis-prevents-flip-flop"],
+        notes: ["fixture records the fixed guard decision; no policy author is invoked"],
+    });
+}
+function makeDuplicateEventIdempotencyCase() {
+    const evidence = hashText("r6 duplicate event input");
+    const memoKey = computeMemoKeyV0({
+        contract_revision: CONTRACT_REVISION,
+        evidence_receipts: [evidence],
+        dependency_receipts: [],
+    });
+    const source = makeReceipt({
+        case_id: "duplicate-event-idempotency",
+        memo_key: memoKey,
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T13:00:00.000Z",
+        next_forecast_recheck: "2026-05-18T19:00:00.000Z",
+        event_cause: "real-input",
+        status: "up",
+        tokens: { fresh: 21, reused: 0 },
+        tags: ["r6", "duplicate", "source"],
+    });
+    const duplicate = createMemoHitReceiptV0({
+        source_receipt: source,
+        as_of: "2026-05-18T13:00:00.000Z",
+        next_forecast_recheck: "2026-05-18T19:00:00.000Z",
+        event_cause: "real-input",
+    });
+    return makeCase({
+        case_id: "duplicate-event-idempotency",
+        title: "Duplicate event is idempotent",
+        represented_by: "source receipt plus memo-hit duplicate receipt",
+        receipts: [source, duplicate],
+        decisions: [
+            makeDecision({
+                case_id: "duplicate-event-idempotency",
+                as_of: duplicate.core.as_of,
+                outcome: "one-decision-for-duplicate-event",
+                reason: "duplicate event reused the memoized verdict instead of spending fresh work",
+                receipts: [source, duplicate],
+                evidence_hashes: [evidence],
+                guardrails: ["memo-key", "idempotent-event-processing"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: source.core.as_of,
+                event: "event-received",
+                observed: { event_id: "evt-r6-duplicate", ordinal: 1 },
+            },
+            {
+                as_of: duplicate.core.as_of,
+                event: "duplicate-event-received",
+                observed: {
+                    event_id: "evt-r6-duplicate",
+                    emitted_decisions: 1,
+                    duplicate_fresh_tokens: duplicate.cost.tokens.fresh,
+                },
+            },
+        ],
+        expected_relationships: ["duplicate-event-idempotent"],
+        notes: ["current SDK events do not expose a typed event id; fixture records it in trace evidence"],
+    });
+}
+function makeStaleStatusFencingCase() {
+    const upstreamEvidence = hashText("r6 stale upstream receipt");
+    const downstreamEvidence = hashText("r6 stale downstream blocked receipt");
+    const upstream = makeReceipt({
+        case_id: "stale-status-fencing",
+        memo_key: "r6:stale:upstream",
+        evidence_input_ids: [upstreamEvidence],
+        as_of: "2026-05-18T11:00:00.000Z",
+        next_forecast_recheck: "2026-05-18T12:00:00.000Z",
+        event_cause: "real-input",
+        status: "up",
+        tokens: { fresh: 16, reused: 0 },
+        tags: ["r6", "stale", "upstream"],
+    });
+    const pin = dependencyReceiptPinFromVerifiedReceiptV0({
+        upstream_receipt: upstream,
+        acceptable_signer_set: ["none"],
+    });
+    const evaluation = evaluateTransitiveFreshnessV0({
+        as_of: "2026-05-18T12:10:00.000Z",
+        transitive_freshness_policy_ref: TRANSITIVE_FRESHNESS_POLICY_REF,
+        consumed_receipts: [
+            {
+                upstream_receipt: upstream,
+                dependency_pin: pin,
+            },
+        ],
+    });
+    if (evaluation.outcome !== "stale-blocked") {
+        throw new Error("stale status fencing fixture must block stale upstream receipts");
+    }
+    const blocked = makeReceipt({
+        case_id: "stale-status-fencing",
+        memo_key: "r6:stale:downstream-blocked",
+        evidence_input_ids: [downstreamEvidence],
+        as_of: "2026-05-18T12:10:00.000Z",
+        next_forecast_recheck: "2026-05-18T12:10:00.000Z",
+        event_cause: "escalation",
+        status: "blocked",
+        blocked: {
+            reason: "stale upstream receipt blocked transitive freshness",
+            fix_target: "upstream-refetch",
+            interrupt_cause: "needs-input",
+        },
+        freshness: {
+            as_of: evaluation.as_of,
+            next_forecast_recheck: evaluation.as_of,
+            transitive_freshness_policy_ref: evaluation.transitive_freshness_policy_ref,
+            consumed_freshness_evaluated: evaluation.consumed_freshness_evaluated,
+        },
+        consumed_receipts: [pin],
+        tokens: { fresh: 0, reused: 0 },
+        tags: ["r6", "stale", "blocked"],
+    });
+    return makeCase({
+        case_id: "stale-status-fencing",
+        title: "Stale upstream status is fenced before downstream use",
+        represented_by: "transitive freshness blocked receipt",
+        receipts: [upstream, blocked],
+        decisions: [
+            makeDecision({
+                case_id: "stale-status-fencing",
+                as_of: blocked.core.as_of,
+                outcome: "stale-blocked",
+                reason: "downstream receipt carried consumed freshness evaluation",
+                receipts: [upstream, blocked],
+                evidence_hashes: [upstreamEvidence, downstreamEvidence],
+                guardrails: ["transitive-freshness", "dependency-pin"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: blocked.core.as_of,
+                event: "transitive-freshness-evaluated",
+                observed: summarizeFreshnessEvaluation(evaluation),
+            },
+        ],
+        expected_relationships: ["stale-status-fenced"],
+        notes: ["stale state is carried as blocked receipt evidence"],
+    });
+}
+function makeContractRevisionFencingCase() {
+    const evidence = hashText("r6 contract revision mismatch");
+    const upstream = makeReceipt({
+        case_id: "contract-revision-fencing",
+        memo_key: "r6:contract:fence",
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T13:10:00.000Z",
+        next_forecast_recheck: "2026-05-18T19:00:00.000Z",
+        event_cause: "real-input",
+        status: "up",
+        tokens: { fresh: 11, reused: 0 },
+        tags: ["r6", "contract", "upstream"],
+    });
+    const validPin = dependencyReceiptPinFromVerifiedReceiptV0({
+        upstream_receipt: upstream,
+        acceptable_signer_set: ["none"],
+    });
+    const attackerPin = {
+        ...validPin,
+        contract_revision: ATTACKER_CONTRACT_REVISION,
+    };
+    let mismatchReason = "contract revision mismatch was not checked";
+    try {
+        verifyUpstreamReceiptDependencyPinV0({
+            upstream_receipt: upstream,
+            expected_dependency_pin: attackerPin,
+        });
+    }
+    catch (error) {
+        mismatchReason =
+            error instanceof Error ? error.message : "contract revision mismatch";
+    }
+    const blocked = makeReceipt({
+        case_id: "contract-revision-fencing",
+        memo_key: "r6:contract:mismatch-blocked",
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T13:11:00.000Z",
+        next_forecast_recheck: "2026-05-18T13:11:00.000Z",
+        event_cause: "escalation",
+        status: "blocked",
+        blocked: {
+            reason: mismatchReason,
+            fix_target: "dependency-pin",
+            interrupt_cause: "contract-declared",
+        },
+        tokens: { fresh: 0, reused: 0 },
+        tags: ["r6", "contract", "blocked"],
+    });
+    return makeCase({
+        case_id: "contract-revision-fencing",
+        title: "Contract revision mismatch is fenced",
+        represented_by: "dependency pin verification and blocked receipt",
+        receipts: [upstream, blocked],
+        decisions: [
+            makeDecision({
+                case_id: "contract-revision-fencing",
+                as_of: blocked.core.as_of,
+                outcome: "contract-mismatch-blocked",
+                reason: mismatchReason,
+                receipts: [upstream, blocked],
+                evidence_hashes: [evidence],
+                guardrails: ["contract-revision-pin", "acceptable-signer-set"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: blocked.core.as_of,
+                event: "dependency-pin-rejected",
+                observed: {
+                    expected_contract_revision: validPin.contract_revision,
+                    supplied_contract_revision: attackerPin.contract_revision,
+                },
+            },
+        ],
+        expected_relationships: ["contract-revision-fenced"],
+        notes: ["mismatched contract does not reach downstream evaluation"],
+    });
+}
+function makePolicyRecompileByteIdenticalRegistryCase() {
+    const evidence = hashText("r6 policy recompile identical registry");
+    const registry = makeRegistrySnapshot();
+    const registryHash = hashCanonicalValue(registry);
+    const receipt = makeReceipt({
+        case_id: "policy-recompile-byte-identical-registry",
+        memo_key: "r6:policy-recompile:byte-identical",
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T14:00:00.000Z",
+        next_forecast_recheck: "2026-05-19T00:00:00.000Z",
+        event_cause: "forecast-recheck",
+        recheck_kind: "plan-age",
+        role: "policy-compile",
+        status: "up",
+        tokens: { fresh: 0, reused: 0 },
+        tags: ["r6", "policy-recompile", "byte-identical"],
+    });
+    return makeCase({
+        case_id: "policy-recompile-byte-identical-registry",
+        title: "Policy recompile preserves byte-identical registry artifact",
+        represented_by: "registry hash before/after decision",
+        receipts: [receipt],
+        decisions: [
+            makeDecision({
+                case_id: "policy-recompile-byte-identical-registry",
+                as_of: receipt.core.as_of,
+                outcome: "registry-byte-identical",
+                reason: "recorded policy recompile produced the same registry bytes",
+                receipts: [receipt],
+                evidence_hashes: [evidence, registryHash],
+                guardrails: ["canonical-policy-artifact", "registry-content-hash"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: receipt.core.as_of,
+                event: "policy-registry-compared",
+                observed: {
+                    before_registry_hash: registryHash,
+                    after_registry_hash: registryHash,
+                    byte_identical: true,
+                },
+            },
+        ],
+        expected_relationships: ["policy-registry-byte-identical"],
+        notes: ["recorded proof does not invoke the policy author or model gateway"],
+    });
+}
+function makeMemoizedVerdictZeroFreshTokensCase() {
+    const evidence = hashText("r6 memoized verdict zero fresh evidence");
+    const memoKey = computeMemoKeyV0({
+        contract_revision: CONTRACT_REVISION,
+        evidence_receipts: [evidence],
+        dependency_receipts: [],
+    });
+    const source = makeReceipt({
+        case_id: "memoized-verdict-zero-fresh-tokens",
+        memo_key: memoKey,
+        evidence_input_ids: [evidence],
+        as_of: "2026-05-18T15:00:00.000Z",
+        next_forecast_recheck: "2026-05-19T00:00:00.000Z",
+        event_cause: "real-input",
+        status: "up",
+        tokens: { fresh: 33, reused: 0 },
+        tags: ["r6", "memo", "source"],
+    });
+    const memoHit = createMemoHitReceiptV0({
+        source_receipt: source,
+        as_of: "2026-05-18T16:00:00.000Z",
+        next_forecast_recheck: "2026-05-19T00:00:00.000Z",
+        event_cause: "forecast-recheck",
+        recheck_kind: "evidence-age",
+    });
+    return makeCase({
+        case_id: "memoized-verdict-zero-fresh-tokens",
+        title: "Memoized verdict reuse spends zero fresh judge tokens",
+        represented_by: "memo-hit receipt",
+        receipts: [source, memoHit],
+        decisions: [
+            makeDecision({
+                case_id: "memoized-verdict-zero-fresh-tokens",
+                as_of: memoHit.core.as_of,
+                outcome: "memo-hit-zero-fresh",
+                reason: "memoized verdict receipt reused prior tokens with fresh=0",
+                receipts: [source, memoHit],
+                evidence_hashes: [evidence],
+                guardrails: ["memo-namespace", "zero-fresh-memo-hit"],
+            }),
+        ],
+        trace: [
+            {
+                as_of: source.core.as_of,
+                event: "memo-source-stored",
+                observed: { fresh: source.cost.tokens.fresh, namespace: MEMO_NAMESPACE },
+            },
+            {
+                as_of: memoHit.core.as_of,
+                event: "memo-hit-reused",
+                observed: {
+                    fresh: memoHit.cost.tokens.fresh,
+                    reused: memoHit.cost.tokens.reused,
+                },
+            },
+        ],
+        expected_relationships: ["memo-hit-has-zero-fresh-tokens"],
+        notes: ["replay uses existing memo-hit receipt helper"],
+    });
+}
+function makeCase(input) {
+    return Object.freeze({
+        ...input,
+        receipts: Object.freeze([...input.receipts]),
+        decisions: Object.freeze([...input.decisions]),
+        trace: Object.freeze([...input.trace]),
+        expected_relationships: Object.freeze([...input.expected_relationships]),
+        evidence_hashes: uniqueSortedHashes([
+            ...input.receipts.map((receipt) => receipt.content_hash),
+            ...input.decisions.flatMap((decision) => decision.evidence_hashes),
+        ]),
+        notes: Object.freeze([...input.notes]),
+    });
+}
+function makeDecision(input) {
+    return Object.freeze({
+        decision_id: `${input.case_id}:${hashText(`${input.outcome}:${input.as_of}`).slice(7, 19)}`,
+        case_id: input.case_id,
+        as_of: input.as_of,
+        outcome: input.outcome,
+        reason: input.reason,
+        receipt_hashes: Object.freeze(input.receipts.map((receipt) => receipt.content_hash)),
+        evidence_hashes: uniqueSortedHashes(input.evidence_hashes),
+        token_summary: sumTokens(input.receipts),
+        guardrails: Object.freeze([...input.guardrails]),
+    });
+}
+function makeReceipt(input) {
+    const role = input.role ?? "judge";
+    const contractRevision = input.contract_revision ?? CONTRACT_REVISION;
+    const freshness = input.freshness ??
+        {
+            as_of: input.as_of,
+            next_forecast_recheck: input.next_forecast_recheck,
+        };
+    return createReceiptV0({
+        core: {
+            responsibility_id: `r6.${input.case_id}`,
+            contract_revision: contractRevision,
+            event_cause: input.event_cause,
+            ...(input.recheck_kind === undefined
+                ? {}
+                : { recheck_kind: input.recheck_kind }),
+            memo_key: input.memo_key,
+            evidence_input_ids: input.evidence_input_ids,
+            as_of: input.as_of,
+            role,
+        },
+        sig: {
+            scheme: "none",
+            null_reason: "cradle R6 recorded release-parity fixture",
+        },
+        verdict: {
+            status: input.status,
+            confidence: {
+                value: input.status === "blocked" ? 0 : 0.86,
+                derivation_method: "recorded-r6-release-parity-fixture",
+                calibration_grade: "none",
+                label_source: "fixture",
+            },
+            ...(input.blocked === undefined ? {} : { blocked: input.blocked }),
+        },
+        freshness,
+        composition: {
+            consumed_receipts: input.consumed_receipts ?? [],
+            cycle_checked: true,
+        },
+        cost: {
+            provider: "cradle",
+            model: "recorded-release-parity",
+            role,
+            tags: input.tags,
+            responsibility_id: `r6.${input.case_id}`,
+            run_id: `r6-${input.case_id}`,
+            as_of: input.as_of,
+            tokens: input.tokens,
+            surprise_cause: input.event_cause,
+        },
+    });
+}
+function makeRegistrySnapshot() {
+    const validationState = {
+        status: "validated",
+        validator_id: "r6-release-parity-recorded-fixture",
+    };
+    return Object.freeze({
+        contract_revision: CONTRACT_REVISION,
+        policy_artifact_id: "policy.r6.release-parity.recorded",
+        policy_artifact_identity: "policy.r6.release-parity.recorded",
+        policy_artifact_namespace: MEMO_NAMESPACE.policy_artifact_namespace,
+        policy_artifact_revision: MEMO_NAMESPACE.policy_artifact_revision,
+        policy_artifact_validation_state: validationState,
+        validation_state: validationState,
+        policy_artifact_bytes: POLICY_ARTIFACT_BYTES,
+        policy_artifact_content_hash: POLICY_ARTIFACT_CONTENT_HASH,
+    });
+}
+function summarizeFreshnessEvaluation(evaluation) {
+    return {
+        outcome: evaluation.outcome,
+        stale_receipt_hashes: evaluation.stale_receipt_hashes,
+        consumed_freshness_evaluated: evaluation.consumed_freshness_evaluated,
+    };
+}
+function releaseParityResult(status, summary, evidence) {
+    return {
+        ok: status === "pass",
+        relationship: "release-parity-fixture",
+        family: "release-parity-fixture",
+        status,
+        summary,
+        evidence: Object.freeze([...evidence]),
+    };
+}
+function assertRequiredCaseCoverage(cases) {
+    const actual = new Set(cases.map((item) => item.case_id));
+    const missing = exports.R6_RELEASE_PARITY_CASE_IDS_V0.filter((caseId) => !actual.has(caseId));
+    const extra = cases
+        .map((item) => item.case_id)
+        .filter((caseId) => !exports.R6_RELEASE_PARITY_CASE_IDS_V0.includes(caseId));
+    if (missing.length > 0 || extra.length > 0) {
+        throw new Error(`R6 release parity case coverage mismatch: missing=${missing.join(",")}; extra=${extra.join(",")}`);
+    }
+}
+function sumTokens(receipts) {
+    return Object.freeze(receipts.reduce((sum, receipt) => ({
+        fresh: sum.fresh + receipt.cost.tokens.fresh,
+        reused: sum.reused + receipt.cost.tokens.reused,
+    }), { fresh: 0, reused: 0 }));
+}
+function uniqueSortedHashes(values) {
+    return Object.freeze(Array.from(new Set(values)).sort());
+}
+function hashText(value) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(value).digest("hex")}`;
+}
+function hashCanonicalValue(value) {
+    return hashCanonicalReceiptV0(canonicalizeForReceiptV0(value));
+}
+function loadReactorComposition() {
+    try {
+        return require("@openprose/reactor/composition");
+    }
+    catch (error) {
+        if (isMissingReactorSubpath(error, "@openprose/reactor/composition")) {
+            return require("../../../reactor/dist/composition");
+        }
+        throw error;
+    }
+}
+function loadReactorForecast() {
+    try {
+        return require("@openprose/reactor/forecast");
+    }
+    catch (error) {
+        if (isMissingReactorSubpath(error, "@openprose/reactor/forecast")) {
+            return require("../../../reactor/dist/forecast");
+        }
+        throw error;
+    }
+}
+function loadReactorMemo() {
+    try {
+        return require("@openprose/reactor/memo");
+    }
+    catch (error) {
+        if (isMissingReactorSubpath(error, "@openprose/reactor/memo")) {
+            return require("../../../reactor/dist/memo");
+        }
+        throw error;
+    }
+}
+function loadReactorReceipt() {
+    try {
+        return require("@openprose/reactor/receipt");
+    }
+    catch (error) {
+        if (isMissingReactorSubpath(error, "@openprose/reactor/receipt")) {
+            return require("../../../reactor/dist/receipt");
+        }
+        throw error;
+    }
+}
+function isMissingReactorSubpath(error, subpath) {
+    return (isRecord(error) &&
+        error["code"] === "MODULE_NOT_FOUND" &&
+        typeof error["message"] === "string" &&
+        error["message"].includes(subpath));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}