@openprose/reactor-cradle 0.1.0-rc.1

package/dist/baselines/cost-thesis/index.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COST_THESIS_GENERATED_AT_V0 = exports.COST_THESIS_SUMMARY_VERSION_V0 = exports.COST_THESIS_SUMMARY_SCHEMA_V0 = void 0;
+exports.createC5StaticCostThesisSummaryV0 = createC5StaticCostThesisSummaryV0;
+exports.measureReactorStaticCostRowV0 = measureReactorStaticCostRowV0;
+exports.measureReactorRuntimeCostRowV0 = measureReactorRuntimeCostRowV0;
+exports.createC5EventChangingCostThesisScenarioV0 = createC5EventChangingCostThesisScenarioV0;
+exports.normalizeNoMemoCostRowV0 = normalizeNoMemoCostRowV0;
+exports.normalizeNaiveLoopCostRowV0 = normalizeNaiveLoopCostRowV0;
+exports.missingEventChangingScenarioV0 = missingEventChangingScenarioV0;
+const node_crypto_1 = require("node:crypto");
+exports.COST_THESIS_SUMMARY_SCHEMA_V0 = "openprose.reactor-cradle.baseline.cost-thesis.summary";
+exports.COST_THESIS_SUMMARY_VERSION_V0 = 0;
+exports.COST_THESIS_GENERATED_AT_V0 = "2026-05-20T00:00:00.000Z";
+function createC5StaticCostThesisSummaryV0(input) {
+    const reactorRow = measureReactorStaticCostRowV0(input.reactor_run);
+    const noMemoRow = normalizeNoMemoCostRowV0(input.no_memo, reactorRow.scenario);
+    const naiveLoopRow = normalizeNaiveLoopCostRowV0(input.naive_loop, reactorRow.scenario);
+    const payload = {
+        schema: exports.COST_THESIS_SUMMARY_SCHEMA_V0,
+        v: exports.COST_THESIS_SUMMARY_VERSION_V0,
+        generated_at: exports.COST_THESIS_GENERATED_AT_V0,
+        static_scenario: {
+            scenario: reactorRow.scenario,
+            status: "measured",
+            rows: Object.freeze([reactorRow, noMemoRow, naiveLoopRow]),
+            notes: Object.freeze([
+                "Static rows share the same incident-briefing-static-zero schedule.",
+                "Only the Reactor row is runtime-produced; no-memo is a simulated replay and naive-loop is a non-Reactor control.",
+            ]),
+        },
+        ...(input.event_changing_scenario === undefined
+            ? {
+                event_changing_scenario: missingEventChangingScenarioV0(),
+            }
+            : { event_changing_scenario: input.event_changing_scenario }),
+        notes: Object.freeze([
+            "C5a emits the reusable measurement summary; report Markdown may render this object but must not invent rows absent here.",
+            "Fresh:reused ratios are exact token-count labels, not reduced fractions.",
+        ]),
+    };
+    return Object.freeze({
+        ...payload,
+        content_hash: contentHash(payload),
+    });
+}
+function measureReactorStaticCostRowV0(run) {
+    if (run.world_profile !== "static") {
+        throw new Error(`Reactor static cost row requires world_profile=static; received ${run.world_profile}`);
+    }
+    return measureReactorRuntimeCostRowV0(run);
+}
+function measureReactorRuntimeCostRowV0(run) {
+    const scenario = scenarioRefFromRun(run);
+    const turns = run.receipt_log.entries.map((receipt, index) => reactorTurnFromReceipt(receipt, index));
+    const tokens = sumTurnTokens(turns);
+    const modelInvocationCount = sumModelInvocations(turns);
+    return Object.freeze({
+        variant: "reactor",
+        label: "Reactor",
+        scenario,
+        provenance: "runtime-produced",
+        receipt_count: run.receipt_log.entries.length,
+        turn_count: turns.length,
+        model_invocation_count: modelInvocationCount,
+        tokens,
+        ratio: tokenRatio(tokens),
+        notes: Object.freeze([
+            "Computed from runtime-produced Reactor receipts in scenario.receipt_log.entries.",
+            "Memo-hit receipts are runtime-produced receipts but do not count as model invocations.",
+            "The static-world row permits the plan-age audit-floor fresh check.",
+        ]),
+        turns: Object.freeze([...turns]),
+    });
+}
+function createC5EventChangingCostThesisScenarioV0(input) {
+    const profile = eventChangingProfile(input.reactor_run.world_profile);
+    const reactorRow = measureReactorRuntimeCostRowV0(input.reactor_run);
+    const noMemoRow = simulateNoMemoEventChangingRowV0(reactorRow);
+    const naiveLoopRow = simulateNaiveLoopEventChangingRowV0(reactorRow);
+    return Object.freeze({
+        status: "measured",
+        scenario_id: input.reactor_run.scenario_id,
+        profile,
+        rows: Object.freeze([reactorRow, noMemoRow, naiveLoopRow]),
+        notes: Object.freeze([
+            "Event-changing rows share the same runtime-produced receipt schedule.",
+            "Only the Reactor row is runtime-produced; no-memo and naive-loop rows are deterministic controls derived from the same per-turn token charges.",
+            "The event-changing control rows intentionally charge memo-hit reusable work as fresh work because those variants have no reusable receipt/memo proof.",
+        ]),
+    });
+}
+function normalizeNoMemoCostRowV0(summary, expectedScenario) {
+    const scenario = {
+        id: summary.scenario.id,
+        profile: summary.scenario.profile,
+        initial_instant: summary.scenario.initial_instant,
+        final_instant: summary.scenario.final_instant,
+    };
+    assertSameScenario(scenario, expectedScenario, "no-memo");
+    const turns = summary.turns.map((turn) => noMemoTurnDetail(turn));
+    const tokens = tokensFromFreshReused(summary.tokens.fresh, summary.tokens.reused);
+    return Object.freeze({
+        variant: "reactor-no-memo",
+        label: "Reactor no memo",
+        scenario,
+        provenance: "simulated",
+        receipt_count: summary.receipt_count,
+        turn_count: summary.turn_count,
+        model_invocation_count: summary.model_invocation_count,
+        tokens,
+        ratio: tokenRatio(tokens),
+        notes: Object.freeze([...summary.notes]),
+        turns: Object.freeze([...turns]),
+        source_summary_hash: summary.content_hash,
+    });
+}
+function normalizeNaiveLoopCostRowV0(summary, expectedScenario) {
+    const scenario = {
+        id: summary.scenario_id,
+        profile: summary.world_profile,
+        initial_instant: expectedScenario?.initial_instant ?? "",
+        final_instant: expectedScenario?.final_instant ?? "",
+    };
+    assertSameScenario(scenario, expectedScenario, "naive-loop");
+    const turns = summary.review_turns.map((turn) => naiveLoopTurnDetail(turn, summary));
+    const tokens = tokensFromFreshReused(summary.tokens.fresh, summary.tokens.reused);
+    return Object.freeze({
+        variant: "naive-loop",
+        label: "Naive loop",
+        scenario,
+        provenance: "control",
+        receipt_count: 0,
+        turn_count: summary.turn_count,
+        model_invocation_count: summary.model_invocation_count,
+        tokens,
+        ratio: tokenRatio(tokens),
+        notes: Object.freeze([...summary.notes]),
+        turns: Object.freeze([...turns]),
+    });
+}
+function missingEventChangingScenarioV0() {
+    return Object.freeze({
+        status: "absent",
+        reason: "C5a did not receive runtime-produced event-changing scenario receipts; no event-changing rows are emitted.",
+        notes: Object.freeze([
+            "This is an honest absence marker for C5b/C5c coordination, not a simulated measurement.",
+        ]),
+    });
+}
+function reactorTurnFromReceipt(receipt, index) {
+    const tokens = tokensFromFreshReused(receipt.cost.tokens.fresh, receipt.cost.tokens.reused);
+    const modelInvocationCount = receipt.cost.provider === "memo" || tokens.total === 0 ? 0 : 1;
+    const outcome = receipt.cost.provider === "memo"
+        ? "memo-hit"
+        : modelInvocationCount === 1
+            ? "model-invocation"
+            : "runtime-receipt";
+    return Object.freeze({
+        index,
+        as_of: receipt.core.as_of,
+        source: "receipt.cost",
+        outcome,
+        tokens,
+        model_invocation_count: modelInvocationCount,
+        event_cause: receipt.core.event_cause,
+        ...(receipt.core.recheck_kind === undefined
+            ? {}
+            : { recheck_kind: receipt.core.recheck_kind }),
+        receipt_hash: receipt.content_hash,
+        provider: receipt.cost.provider,
+        model: receipt.cost.model,
+        role: receipt.core.role,
+        note: outcome === "memo-hit"
+            ? "Runtime memo-hit receipt reused a prior verdict and made no model call."
+            : outcome === "runtime-receipt"
+                ? "Runtime receipt carried no token-bearing model call."
+                : reactorInvocationNote(receipt),
+    });
+}
+function noMemoTurnDetail(turn) {
+    const tokens = tokensFromFreshReused(turn.tokens.fresh, turn.tokens.reused);
+    return Object.freeze({
+        index: turn.index,
+        as_of: turn.as_of,
+        source: "no-memo-simulation",
+        outcome: "fresh-judge",
+        tokens,
+        model_invocation_count: turn.model_invocation_count,
+        event_cause: turn.event_cause,
+        ...(turn.recheck_kind === undefined ? {} : { recheck_kind: turn.recheck_kind }),
+        note: turn.note,
+    });
+}
+function naiveLoopTurnDetail(turn, summary) {
+    const charged = summary.per_invocation_tokens.charged;
+    return Object.freeze({
+        index: turn.index,
+        as_of: turn.as_of,
+        source: "naive-loop-control",
+        outcome: "control-review",
+        tokens: tokensFromFreshReused(charged.fresh, charged.reused),
+        model_invocation_count: 1,
+        ...(turn.recheck_kind === undefined ? {} : { recheck_kind: turn.recheck_kind }),
+        review_kind: turn.review_kind,
+        source_ids: Object.freeze([...turn.source_ids]),
+        note: `${turn.review_kind} over ${turn.source_ids.join(", ")} with no receipt or memo reuse.`,
+    });
+}
+function simulateNoMemoEventChangingRowV0(reactorRow) {
+    const turns = reactorRow.turns.map((turn) => simulateNoMemoEventTurnV0(turn));
+    const tokens = sumTurnTokens(turns);
+    return Object.freeze({
+        variant: "reactor-no-memo",
+        label: "Reactor no memo",
+        scenario: reactorRow.scenario,
+        provenance: "simulated",
+        receipt_count: reactorRow.receipt_count,
+        turn_count: turns.length,
+        model_invocation_count: sumModelInvocations(turns),
+        tokens,
+        ratio: tokenRatio(tokens),
+        notes: Object.freeze([
+            "Event-changing no-memo control derived from the runtime-produced event-changing receipt schedule.",
+            "Each token-bearing turn is charged as fresh work; memo-hit reusable tokens are not credited as reuse.",
+            "This is a deterministic control row, not a runtime flag or alternate Reactor execution mode.",
+        ]),
+        turns: Object.freeze([...turns]),
+    });
+}
+function simulateNaiveLoopEventChangingRowV0(reactorRow) {
+    const turns = reactorRow.turns.map((turn) => simulateNaiveLoopEventTurnV0(turn));
+    const tokens = sumTurnTokens(turns);
+    return Object.freeze({
+        variant: "naive-loop",
+        label: "Naive loop",
+        scenario: reactorRow.scenario,
+        provenance: "control",
+        receipt_count: 0,
+        turn_count: turns.length,
+        model_invocation_count: sumModelInvocations(turns),
+        tokens,
+        ratio: tokenRatio(tokens),
+        notes: Object.freeze([
+            "Event-changing naive-loop control over the same receipt-bearing schedule.",
+            "Every review turn rereads the current evidence and spends the runtime row's per-turn total as fresh work.",
+            "The control has no receipts, memo keys, forecast policy, stable content identity, or reusable verdict architecture.",
+        ]),
+        turns: Object.freeze([...turns]),
+    });
+}
+function simulateNoMemoEventTurnV0(turn) {
+    const tokens = tokensFromFreshReused(turn.tokens.total, 0);
+    return Object.freeze({
+        index: turn.index,
+        as_of: turn.as_of,
+        source: "no-memo-simulation",
+        outcome: "fresh-judge",
+        tokens,
+        model_invocation_count: tokens.total === 0 ? 0 : 1,
+        ...(turn.event_cause === undefined ? {} : { event_cause: turn.event_cause }),
+        ...(turn.recheck_kind === undefined ? {} : { recheck_kind: turn.recheck_kind }),
+        note: "No-memo event-changing control charges this turn's runtime token total as fresh judge work.",
+    });
+}
+function simulateNaiveLoopEventTurnV0(turn) {
+    const tokens = tokensFromFreshReused(turn.tokens.total, 0);
+    return Object.freeze({
+        index: turn.index,
+        as_of: turn.as_of,
+        source: "naive-loop-control",
+        outcome: "control-review",
+        tokens,
+        model_invocation_count: tokens.total === 0 ? 0 : 1,
+        ...(turn.recheck_kind === undefined ? {} : { recheck_kind: turn.recheck_kind }),
+        review_kind: turn.event_cause === "forecast-recheck" ? "scheduled-review" : "real-input-review",
+        note: "Naive-loop event-changing control reviews the same turn without receipt or memo reuse.",
+    });
+}
+function reactorInvocationNote(receipt) {
+    if (receipt.core.event_cause === "forecast-recheck" &&
+        receipt.core.recheck_kind === "plan-age") {
+        return "Runtime judge invocation for the plan-age audit floor.";
+    }
+    return "Runtime judge invocation charged from adapter-owned model usage.";
+}
+function scenarioRefFromRun(run) {
+    return Object.freeze({
+        id: run.scenario_id,
+        profile: run.world_profile,
+        initial_instant: run.initial_instant,
+        final_instant: run.final_instant,
+    });
+}
+function eventChangingProfile(profile) {
+    if (profile === "static") {
+        throw new Error("event-changing cost thesis scenario requires a non-static world profile");
+    }
+    return profile;
+}
+function assertSameScenario(observed, expected, label) {
+    if (expected === undefined) {
+        return;
+    }
+    if (observed.id !== expected.id || observed.profile !== expected.profile) {
+        throw new Error(`${label} scenario mismatch: expected ${expected.id}/${expected.profile}, received ${observed.id}/${observed.profile}`);
+    }
+}
+function sumTurnTokens(turns) {
+    const fresh = turns.reduce((sum, turn) => sum + turn.tokens.fresh, 0);
+    const reused = turns.reduce((sum, turn) => sum + turn.tokens.reused, 0);
+    return tokensFromFreshReused(fresh, reused);
+}
+function sumModelInvocations(turns) {
+    return turns.reduce((sum, turn) => sum + turn.model_invocation_count, 0);
+}
+function tokensFromFreshReused(fresh, reused) {
+    return Object.freeze({
+        fresh,
+        reused,
+        total: fresh + reused,
+    });
+}
+function tokenRatio(tokens) {
+    return Object.freeze({
+        fresh: tokens.fresh,
+        reused: tokens.reused,
+        label: `${tokens.fresh}:${tokens.reused}`,
+        reused_is_zero: tokens.reused === 0,
+    });
+}
+function contentHash(payload) {
+    const digest = (0, node_crypto_1.createHash)("sha256")
+        .update(JSON.stringify(payload))
+        .digest("hex");
+    return `sha256:${digest}`;
+}

package/dist/baselines/naive-loop/index.d.ts

@@ -0,0 +1,46 @@
+import type { ModelGatewayCassetteV0 } from "../../replay/model-gateway";
+import type { ReactorScenarioV0 } from "../../scenario/types";
+export declare const NAIVE_LOOP_BASELINE_SCHEMA_V0: "openprose.reactor-cradle.baseline.naive-loop.summary";
+export declare const NAIVE_LOOP_BASELINE_VERSION_V0: 0;
+export declare const NAIVE_LOOP_VARIANT_NAME_V0: "naive-loop";
+export type NaiveLoopReviewKindV0 = "scripted-model-review" | "real-input-review" | "scheduled-review";
+export type NaiveLoopReviewStepKindV0 = "model" | "ingest" | "tick";
+export interface NaiveLoopTokenSummaryV0 {
+    readonly fresh: number;
+    readonly reused: number;
+}
+export interface NaiveLoopPerInvocationTokenChargeV0 {
+    readonly recorded: NaiveLoopTokenSummaryV0;
+    readonly charged: NaiveLoopTokenSummaryV0;
+}
+export interface NaiveLoopReviewTurnV0 {
+    readonly index: number;
+    readonly step_kind: NaiveLoopReviewStepKindV0;
+    readonly review_kind: NaiveLoopReviewKindV0;
+    readonly as_of: string;
+    readonly prompt: string;
+    readonly source_ids: readonly string[];
+    readonly recheck_kind?: "evidence-age" | "plan-age";
+}
+export interface NaiveLoopBaselineSummaryV0 {
+    readonly schema: typeof NAIVE_LOOP_BASELINE_SCHEMA_V0;
+    readonly v: typeof NAIVE_LOOP_BASELINE_VERSION_V0;
+    readonly scenario_id: string;
+    readonly world_profile: ReactorScenarioV0["world"]["profile"];
+    readonly variant: typeof NAIVE_LOOP_VARIANT_NAME_V0;
+    readonly turn_count: number;
+    readonly model_invocation_count: number;
+    readonly tokens: NaiveLoopTokenSummaryV0;
+    readonly ratio: string;
+    readonly per_invocation_tokens: NaiveLoopPerInvocationTokenChargeV0;
+    readonly review_turns: readonly NaiveLoopReviewTurnV0[];
+    readonly notes: readonly string[];
+}
+export interface MeasureNaiveLoopBaselineInputV0 {
+    readonly scenario: ReactorScenarioV0;
+    readonly cassette: ModelGatewayCassetteV0;
+    readonly prompt?: string;
+    readonly include_scripted_model_steps?: boolean;
+}
+export declare function measureNaiveLoopBaselineV0(input: MeasureNaiveLoopBaselineInputV0): NaiveLoopBaselineSummaryV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/baselines/naive-loop/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/baselines/naive-loop/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAMzE,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,6BAA6B,EACxC,sDAA+D,CAAC;AAClE,eAAO,MAAM,8BAA8B,EAAG,CAAU,CAAC;AACzD,eAAO,MAAM,0BAA0B,EAAG,YAAqB,CAAC;AAEhE,MAAM,MAAM,qBAAqB,GAC7B,uBAAuB,GACvB,mBAAmB,GACnB,kBAAkB,CAAC;AAEvB,MAAM,MAAM,yBAAyB,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEpE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAC;CAC3C;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC;IAC9C,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,YAAY,CAAC,EAAE,cAAc,GAAG,UAAU,CAAC;CACrD;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,MAAM,EAAE,OAAO,6BAA6B,CAAC;IACtD,QAAQ,CAAC,CAAC,EAAE,OAAO,8BAA8B,CAAC;IAClD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC;IAC9D,QAAQ,CAAC,OAAO,EAAE,OAAO,0BAA0B,CAAC;IACpD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,qBAAqB,EAAE,mCAAmC,CAAC;IACpE,QAAQ,CAAC,YAAY,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACxD,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACjD;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,+BAA+B,GACrC,0BAA0B,CAkD5B"}

package/dist/baselines/naive-loop/index.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAIVE_LOOP_VARIANT_NAME_V0 = exports.NAIVE_LOOP_BASELINE_VERSION_V0 = exports.NAIVE_LOOP_BASELINE_SCHEMA_V0 = void 0;
+exports.measureNaiveLoopBaselineV0 = measureNaiveLoopBaselineV0;
+const time_1 = require("../../scenario/time");
+exports.NAIVE_LOOP_BASELINE_SCHEMA_V0 = "openprose.reactor-cradle.baseline.naive-loop.summary";
+exports.NAIVE_LOOP_BASELINE_VERSION_V0 = 0;
+exports.NAIVE_LOOP_VARIANT_NAME_V0 = "naive-loop";
+function measureNaiveLoopBaselineV0(input) {
+    const recorded = readRecordedJudgeTokenSummary(input.cassette);
+    const charged = Object.freeze({
+        fresh: recorded.fresh + recorded.reused,
+        reused: 0,
+    });
+    if (charged.fresh <= 0) {
+        throw new Error("naive-loop baseline requires a positive cassette token charge");
+    }
+    const prompt = input.prompt ?? firstScenarioJudgePrompt(input.scenario) ?? "review-static-world";
+    const reviewTurns = collectNaiveLoopReviewTurns({
+        scenario: input.scenario,
+        prompt,
+        includeScriptedModelSteps: input.include_scripted_model_steps ?? false,
+    });
+    if (reviewTurns.length === 0) {
+        throw new Error("naive-loop baseline requires at least one review turn");
+    }
+    const tokens = Object.freeze({
+        fresh: multiplySafe(charged.fresh, reviewTurns.length, "naive-loop fresh tokens"),
+        reused: 0,
+    });
+    return Object.freeze({
+        schema: exports.NAIVE_LOOP_BASELINE_SCHEMA_V0,
+        v: exports.NAIVE_LOOP_BASELINE_VERSION_V0,
+        scenario_id: input.scenario.id,
+        world_profile: input.scenario.world.profile,
+        variant: exports.NAIVE_LOOP_VARIANT_NAME_V0,
+        turn_count: reviewTurns.length,
+        model_invocation_count: reviewTurns.length,
+        tokens,
+        ratio: formatFreshReusedRatio(tokens),
+        per_invocation_tokens: Object.freeze({
+            recorded,
+            charged,
+        }),
+        review_turns: Object.freeze([...reviewTurns]),
+        notes: Object.freeze([
+            "Non-Reactor control: no receipts, memo keys, forecast policy, stable content identity, or reusable verdict architecture.",
+            "Every counted review turn rereads the scenario sources for that turn and sends a fresh prompt.",
+            `Per-review charge is the recorded judge cassette total (fresh + reused = ${charged.fresh}) converted to fresh tokens, so the baseline uses the same cassette usage shape without claiming reuse.`,
+            "Scripted model steps are Cradle replay setup unless include_scripted_model_steps is true; ingest and tick review steps are the counted model invocations.",
+            "Scripted read steps are evidence reads only and do not add a model invocation unless paired with a counted review turn.",
+            "Static evidence is intentionally unchanged; this baseline still re-prompts because a cron/prompt loop has no receipt/memo proof that the prior judgment is reusable.",
+        ]),
+    });
+}
+function collectNaiveLoopReviewTurns(input) {
+    const initialInstant = (0, time_1.canonicalScenarioInstant)(input.scenario.initial_instant, "scenario.initial_instant");
+    const initialEpochMs = (0, time_1.parseScenarioInstantMs)(initialInstant, "scenario.initial_instant");
+    let currentEpochMs = initialEpochMs;
+    const turns = [];
+    for (const [index, step] of input.scenario.script.entries()) {
+        currentEpochMs = stepEpochMs(step, initialEpochMs, currentEpochMs);
+        const turn = reviewTurnForStep({
+            scenario: input.scenario,
+            step,
+            index,
+            asOf: new Date(currentEpochMs).toISOString(),
+            prompt: input.prompt,
+            includeScriptedModelSteps: input.includeScriptedModelSteps,
+        });
+        if (turn !== undefined) {
+            turns.push(turn);
+        }
+    }
+    return Object.freeze(turns);
+}
+function stepEpochMs(step, initialEpochMs, currentEpochMs) {
+    if ("at" in step.time) {
+        const nextEpochMs = initialEpochMs + (0, time_1.parseScenarioDurationMs)(step.time.at, "script at");
+        if (nextEpochMs < currentEpochMs) {
+            throw new Error(`scenario step cannot move time backward to ${step.time.at}`);
+        }
+        return nextEpochMs;
+    }
+    return currentEpochMs + (0, time_1.parseScenarioDurationMs)(step.time.after, "script after");
+}
+function reviewTurnForStep(input) {
+    switch (input.step.kind) {
+        case "model":
+            if (!input.includeScriptedModelSteps ||
+                input.step.request_kind !== "judge") {
+                return undefined;
+            }
+            return Object.freeze({
+                index: input.index,
+                step_kind: "model",
+                review_kind: "scripted-model-review",
+                as_of: input.asOf,
+                prompt: input.step.prompt,
+                source_ids: scenarioSourceIds(input.scenario),
+            });
+        case "ingest":
+            return Object.freeze({
+                index: input.index,
+                step_kind: "ingest",
+                review_kind: "real-input-review",
+                as_of: input.asOf,
+                prompt: input.prompt,
+                source_ids: input.step.source_id === undefined
+                    ? scenarioSourceIds(input.scenario)
+                    : Object.freeze([input.step.source_id]),
+            });
+        case "tick":
+            return Object.freeze({
+                index: input.index,
+                step_kind: "tick",
+                review_kind: "scheduled-review",
+                as_of: input.asOf,
+                prompt: input.prompt,
+                source_ids: scenarioSourceIds(input.scenario),
+                ...(input.step.recheck_kind === undefined
+                    ? {}
+                    : { recheck_kind: input.step.recheck_kind }),
+            });
+        case "read":
+            return undefined;
+    }
+}
+function scenarioSourceIds(scenario) {
+    return Object.freeze(scenario.sources.map((source) => source.id));
+}
+function firstScenarioJudgePrompt(scenario) {
+    for (const step of scenario.script) {
+        if (step.kind === "model" && step.request_kind === "judge") {
+            return step.prompt;
+        }
+    }
+    return undefined;
+}
+function readRecordedJudgeTokenSummary(cassette) {
+    const exchange = cassette.exchanges.find((item) => item.request.kind === "judge") ??
+        cassette.exchanges[0];
+    if (exchange === undefined) {
+        throw new Error("naive-loop baseline requires a cassette exchange");
+    }
+    return readResponseTokenSummary(exchange.response);
+}
+function readResponseTokenSummary(response) {
+    if (response.usage !== undefined) {
+        return Object.freeze({
+            fresh: readTokenCount(response.usage.tokens.fresh, "response.usage.tokens.fresh"),
+            reused: readTokenCount(response.usage.tokens.reused, "response.usage.tokens.reused"),
+        });
+    }
+    const payloadTokens = readPayloadTokens(response.payload);
+    if (payloadTokens !== undefined) {
+        return payloadTokens;
+    }
+    throw new Error("model gateway response must include usage tokens or payload tokens");
+}
+function readPayloadTokens(payload) {
+    if (!isRecord(payload) || !isRecord(payload["tokens"])) {
+        return undefined;
+    }
+    return Object.freeze({
+        fresh: readTokenCount(payload["tokens"]["fresh"], "response.payload.tokens.fresh"),
+        reused: readTokenCount(payload["tokens"]["reused"], "response.payload.tokens.reused"),
+    });
+}
+function readTokenCount(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function multiplySafe(left, right, label) {
+    const product = left * right;
+    if (!Number.isSafeInteger(product)) {
+        throw new Error(`${label} exceeded the safe integer range`);
+    }
+    return product;
+}
+function formatFreshReusedRatio(tokens) {
+    return `${tokens.fresh}:${tokens.reused}`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/baselines/no-memo/index.d.ts

@@ -0,0 +1,84 @@
+import type { ContentHashV0, ReceiptEventCauseV0, ReceiptRecheckKindV0 } from "@openprose/reactor/receipt";
+import type { ScenarioRunReceiptV0 } from "../../scenario/types";
+export declare const NO_MEMO_BASELINE_SUMMARY_SCHEMA_V0: "openprose.reactor-cradle.baseline.no-memo-summary";
+export declare const NO_MEMO_BASELINE_SUMMARY_VERSION_V0: 0;
+export declare const NO_MEMO_BASELINE_VARIANT_V0: "reactor-no-memo";
+export declare const NO_MEMO_BASELINE_SCENARIO_ID_V0: "incident-briefing-static-zero";
+export declare const NO_MEMO_BASELINE_WORLD_PROFILE_V0: "static";
+export declare const NO_MEMO_BASELINE_CASSETTE_PATH_V0: "./c2-static-zero.model-cassette.json";
+export declare const NO_MEMO_BASELINE_SOURCE_FIXTURE_V0: "src/__tests__/fixtures/c2-static-zero.scenario";
+export declare const NO_MEMO_BASELINE_GENERATED_AT_V0: "2026-05-20T00:00:00.000Z";
+export type NoMemoBaselineSummaryTypeV0 = "runtime-derived-static-no-memo-replay";
+export type NoMemoBaselineRuntimeEquivalentV0 = "model-invocation-equivalent" | "memo-hit-equivalent";
+export type NoMemoBaselineOutcomeV0 = "fresh-judge";
+export interface NoMemoBaselineTokensV0 {
+    readonly fresh: number;
+    readonly reused: number;
+    readonly total: number;
+}
+export interface NoMemoBaselineRatioV0 {
+    readonly fresh: number;
+    readonly reused: number;
+    readonly label: string;
+    readonly reused_is_zero: boolean;
+}
+export interface NoMemoBaselineScenarioV0 {
+    readonly id: typeof NO_MEMO_BASELINE_SCENARIO_ID_V0;
+    readonly profile: typeof NO_MEMO_BASELINE_WORLD_PROFILE_V0;
+    readonly initial_instant: string;
+    readonly final_instant: string;
+    readonly source_fixture: string;
+    readonly cassette_path: typeof NO_MEMO_BASELINE_CASSETTE_PATH_V0;
+    readonly scenario_script_turn_count: number;
+}
+export interface NoMemoBaselineTurnV0 {
+    readonly index: number;
+    readonly as_of: string;
+    readonly event_cause: ReceiptEventCauseV0;
+    readonly recheck_kind?: ReceiptRecheckKindV0;
+    readonly runtime_equivalent: NoMemoBaselineRuntimeEquivalentV0;
+    readonly no_memo_outcome: NoMemoBaselineOutcomeV0;
+    readonly model_invocation_count: number;
+    readonly tokens: NoMemoBaselineTokensV0;
+    readonly source_tokens: NoMemoBaselineTokensV0;
+    readonly source_provider: string;
+    readonly source_model: string;
+    readonly source_receipt_hash?: ContentHashV0;
+    readonly deterministic_profile: string;
+    readonly note: string;
+}
+export interface NoMemoBaselineAssumptionsV0 {
+    readonly replay_mode: "same-runtime-receipt-log-with-memo-disabled-equivalent";
+    readonly memo_hit_handling: "token-bearing-receipts-charge-total-as-fresh";
+    readonly runtime_behavior_changed: false;
+    readonly excluded_invocations: readonly string[];
+}
+export interface NoMemoBaselineSummaryV0 {
+    readonly schema: typeof NO_MEMO_BASELINE_SUMMARY_SCHEMA_V0;
+    readonly v: typeof NO_MEMO_BASELINE_SUMMARY_VERSION_V0;
+    readonly summary_type: NoMemoBaselineSummaryTypeV0;
+    readonly generated_at: typeof NO_MEMO_BASELINE_GENERATED_AT_V0;
+    readonly variant: typeof NO_MEMO_BASELINE_VARIANT_V0;
+    readonly scenario: NoMemoBaselineScenarioV0;
+    readonly receipt_count: number;
+    readonly turn_count: number;
+    readonly memo_hit_equivalent_count: number;
+    readonly model_invocation_count: number;
+    readonly tokens: NoMemoBaselineTokensV0;
+    readonly ratio: NoMemoBaselineRatioV0;
+    readonly assumptions: NoMemoBaselineAssumptionsV0;
+    readonly turns: readonly NoMemoBaselineTurnV0[];
+    readonly notes: readonly string[];
+    readonly content_hash: ContentHashV0;
+}
+export interface RunNoMemoW7StaticBaselineInputV0 {
+    readonly reactor_run?: ScenarioRunReceiptV0;
+    readonly source_fixture?: string;
+}
+export interface CreateNoMemoStaticBaselineFromReactorRunInputV0 {
+    readonly reactor_run: ScenarioRunReceiptV0;
+    readonly source_fixture?: string;
+}
+export declare function createNoMemoStaticBaselineFromReactorRunV0(input: CreateNoMemoStaticBaselineFromReactorRunInputV0): NoMemoBaselineSummaryV0;
+export declare function runNoMemoW7StaticBaselineV0(input?: RunNoMemoW7StaticBaselineInputV0): NoMemoBaselineSummaryV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/baselines/no-memo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/baselines/no-memo/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EAErB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,eAAO,MAAM,kCAAkC,EAC7C,mDAA4D,CAAC;AAC/D,eAAO,MAAM,mCAAmC,EAAG,CAAU,CAAC;AAC9D,eAAO,MAAM,2BAA2B,EAAG,iBAA0B,CAAC;AACtE,eAAO,MAAM,+BAA+B,EAC1C,+BAAwC,CAAC;AAC3C,eAAO,MAAM,iCAAiC,EAAG,QAAiB,CAAC;AACnE,eAAO,MAAM,iCAAiC,EAC5C,sCAA+C,CAAC;AAClD,eAAO,MAAM,kCAAkC,EAC7C,gDAAyD,CAAC;AAC5D,eAAO,MAAM,gCAAgC,EAC3C,0BAAmC,CAAC;AAEtC,MAAM,MAAM,2BAA2B,GACrC,uCAAuC,CAAC;AAC1C,MAAM,MAAM,iCAAiC,GACzC,6BAA6B,GAC7B,qBAAqB,CAAC;AAC1B,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC;AAEpD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,EAAE,OAAO,+BAA+B,CAAC;IACpD,QAAQ,CAAC,OAAO,EAAE,OAAO,iCAAiC,CAAC;IAC3D,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,OAAO,iCAAiC,CAAC;IACjE,QAAQ,CAAC,0BAA0B,EAAE,MAAM,CAAC;CAC7C;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAC;IAC1C,QAAQ,CAAC,YAAY,CAAC,EAAE,oBAAoB,CAAC;IAC7C,QAAQ,CAAC,kBAAkB,EAAE,iCAAiC,CAAC;IAC/D,QAAQ,CAAC,eAAe,EAAE,uBAAuB,CAAC;IAClD,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,aAAa,EAAE,sBAAsB,CAAC;IAC/C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC;IAC7C,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,WAAW,EAClB,wDAAwD,CAAC;IAC3D,QAAQ,CAAC,iBAAiB,EACxB,8CAA8C,CAAC;IACjD,QAAQ,CAAC,wBAAwB,EAAE,KAAK,CAAC;IACzC,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC;CAClD;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,MAAM,EAAE,OAAO,kCAAkC,CAAC;IAC3D,QAAQ,CAAC,CAAC,EAAE,OAAO,mCAAmC,CAAC;IACvD,QAAQ,CAAC,YAAY,EAAE,2BAA2B,CAAC;IACnD,QAAQ,CAAC,YAAY,EAAE,OAAO,gCAAgC,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,OAAO,2BAA2B,CAAC;IACrD,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,yBAAyB,EAAE,MAAM,CAAC;IAC3C,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,2BAA2B,CAAC;IAClD,QAAQ,CAAC,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC;CACtC;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,+CAA+C;IAC9D,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAiED,wBAAgB,0CAA0C,CACxD,KAAK,EAAE,+CAA+C,GACrD,uBAAuB,CAczB;AAED,wBAAgB,2BAA2B,CACzC,KAAK,GAAE,gCAAqC,GAC3C,uBAAuB,CAoBzB"}