@skillstate/bench 3.0.0 → 3.0.1

package/dist/ab/record.js

@@ -0,0 +1,98 @@
+/**
+ * The shape of one A/B run record.
+ *
+ * ── Why a record and not a number ────────────────────────────────────────
+ *
+ * The previous A/B produced a number — "39% saved" — from a run in which
+ * the instrumented arm never once touched the state file. The number was
+ * arithmetically correct and scientifically meaningless, and nothing in the
+ * pipeline could tell the difference, because the pipeline carried a number
+ * instead of a record.
+ *
+ * A record keeps the things that decide whether a comparison means anything:
+ * what the task was, what each arm spent, and — the part that was missing —
+ * **whether the instrumentation was engaged at all**. Gates in `verdict.ts`
+ * read these fields; none of them is derivable from token counts.
+ *
+ * @non-paper — measurement infrastructure for OUR host integration. Not
+ * part of the paper's own evaluation.
+ */
+/** Every arm, in the order an experiment should run them. */
+export const ARM_IDS = ['plain', 'notes', 'paper'];
+/**
+ * Whether an arm has the skillstate integration switched ON.
+ *
+ * `plain` is the control: no plugin, no state, no system fragment. The other
+ * two carry the integration in its two modes.
+ */
+export function isInstrumented(arm) {
+    return arm !== 'plain';
+}
+/**
+ * Tokens that constitute PROMPT cost.
+ *
+ * `input + cacheRead` is what the model had to be shown, whether it was
+ * billed as fresh or served from cache. `cacheWrite` is excluded because it
+ * is an artefact of a cold cache rather than of prompt size, and folding it
+ * in would make a run that happened to miss the cache look like an expensive
+ * one. `output` is excluded because the paper's claim is about prompt
+ * economy, not generation economy.
+ */
+export function promptTokens(usage) {
+    return usage.input + usage.cacheRead;
+}
+/** Engagement for a run whose arm carries no integration. */
+export const CONTROL_ENGAGEMENT = {
+    engaged: false,
+    writes: 0,
+    sinkWrites: 0,
+    rejections: 0,
+    hadStateAtStep0: false,
+};
+/**
+ * Build an {@link ArmRecord} from its runs, checking they are commensurable.
+ *
+ * A trial index must be unique within an arm: two runs labelled `trial: 0`
+ * are two samples of the same cell, and silently averaging them would hide
+ * exactly the variance the harness exists to surface.
+ *
+ * Returns a typed failure rather than throwing — a malformed arm is a
+ * harness bug, and the caller must be able to report it as one.
+ */
+export function buildArmRecord(arm, runs) {
+    if (runs.length === 0) {
+        return { ok: false, reason: `arm ${arm} has no runs` };
+    }
+    const first = runs[0];
+    const mismatched = (field) => {
+        for (const run of runs) {
+            if (run[field] !== first[field]) {
+                return `arm ${arm}: ${String(field)} differs across runs ("${String(first[field])}" vs "${String(run[field])}")`;
+            }
+        }
+        return undefined;
+    };
+    for (const field of ['task', 'model', 'hostVersion', 'arm']) {
+        const problem = mismatched(field);
+        if (problem !== undefined)
+            return { ok: false, reason: problem };
+    }
+    const seen = new Set();
+    for (const run of runs) {
+        if (seen.has(run.trial)) {
+            return { ok: false, reason: `arm ${arm}: duplicate trial index ${run.trial}` };
+        }
+        seen.add(run.trial);
+    }
+    return {
+        ok: true,
+        record: {
+            arm,
+            task: first.task,
+            model: first.model,
+            hostVersion: first.hostVersion,
+            runs: [...runs].sort((a, b) => a.trial - b.trial),
+        },
+    };
+}
+//# sourceMappingURL=record.js.map

package/dist/ab/record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.js","sourceRoot":"","sources":["../../src/ab/record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,6DAA6D;AAC7D,MAAM,CAAC,MAAM,OAAO,GAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAErE;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,GAAU;IACvC,OAAO,GAAG,KAAK,OAAO,CAAC;AACzB,CAAC;AAcD;;;;;;;;;GASG;AACH,MAAM,UAAU,YAAY,CAAC,KAAiB;IAC5C,OAAO,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC;AACvC,CAAC;AA8BD,6DAA6D;AAC7D,MAAM,CAAC,MAAM,kBAAkB,GAAuB;IACpD,OAAO,EAAE,KAAK;IACd,MAAM,EAAE,CAAC;IACT,UAAU,EAAE,CAAC;IACb,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,KAAK;CACvB,CAAC;AAgFF;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAC5B,GAAU,EACV,IAA0B;IAE1B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAG,cAAc,EAAE,CAAC;IACzD,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAE,CAAC;IACvB,MAAM,UAAU,GAAG,CAAC,KAAsB,EAAsB,EAAE;QAChE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;gBAChC,OAAO,OAAO,GAAG,KAAK,MAAM,CAAC,KAAK,CAAC,0BAA0B,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;YACnH,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK,CAAU,EAAE,CAAC;QACrE,MAAM,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IACnE,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAG,2BAA2B,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC;QACjF,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IAED,OAAO;QACL,EAAE,EAAE,IAAI;QACR,MAAM,EAAE;YACN,GAAG;YACH,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;SAClD;KACF,CAAC;AACJ,CAAC"}

package/dist/ab/replay.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Reconstructing the host's token curve, and what a bounded prompt would cost.
+ *
+ * ── Why this exists, given the A/B harness ───────────────────────────────
+ *
+ * The harness answers "does the integration save tokens, on a live host". That
+ * question needs a live host, and the account quota is currently negative, so
+ * it cannot be answered today by running more experiments.
+ *
+ * This module answers a different and much narrower question that needs no
+ * model at all: **given a real session's real token accounting, what would a
+ * bounded Aₜ = (P, Σₜ, Oₜ) prompt have cost on those same steps?**
+ *
+ * That is not a substitute for the A/B, and the difference matters:
+ *
+ * - the A/B measures whether an agent, given a bounded prompt, still does the
+ *   work — an outcome question this cannot touch;
+ * - this measures the COST side only, using token counts the host itself
+ *   recorded, with no model in the loop.
+ *
+ * Both are needed. A cost win with no task completion is worthless, and a task
+ * completion with no cost win is not the claim the paper makes. This module
+ * deliberately reports the half it can actually measure, and refuses to
+ * extrapolate to the half it cannot.
+ *
+ * ── Where the numbers come from ──────────────────────────────────────────
+ *
+ * OpenCode records per-message `tokens` — `input`, `cache.read`,
+ * `cache.write`, `output`, `reasoning` — in its own store. Those are the
+ * host's own accounting for a real session, not our reconstruction of it.
+ *
+ * `cache.read` is the interesting one, and the reason this is not a
+ * hypothetical. A growing transcript does not merely cost more to send: the
+ * host caches the prefix, so the re-sent history is billed as cache reads.
+ * Ignoring them would report a saving of a few percent and hide the actual
+ * shape of the cost.
+ *
+ * @non-paper — measurement infrastructure, not the paper's evaluation.
+ */
+import type { Distribution, EffectSize } from './stats-core.js';
+/** One assistant step's token accounting, as the host recorded it. */
+export interface StepUsage {
+    /** Fresh, uncached input tokens. */
+    readonly input: number;
+    /** Input tokens served from the prefix cache. */
+    readonly cacheRead: number;
+    /** Output tokens. */
+    readonly output: number;
+}
+/**
+ * What a cache read is worth relative to a fresh input token.
+ *
+ * `1/10` is the usual published rate for prompt caching, and it is a DEFAULT,
+ * not a measurement: the real multiplier is the provider's, and this repo has
+ * no access to anyone's invoice. The number exists because adding `cache.read`
+ * to `input` at face value is the single easiest way to overstate a token
+ * saving, and that is worth a knob rather than a silent assumption.
+ *
+ * A cache read is NOT free: the model is shown the same text either way, and
+ * the paper's claim is about what the model is exposed to. The discount
+ * reflects PRICE, not attention.
+ */
+export declare const DEFAULT_CACHE_READ_DISCOUNT = 0.1;
+/** Fresh input plus cache reads, i.e. everything the model was shown. */
+export declare function promptTokensOf(step: StepUsage): number;
+/** Options for {@link reconstruct}. */
+export interface ReconstructOptions {
+    /**
+     * Tokens a single bounded Aₜ prompt costs.
+     *
+     * Defaults to `DEFAULT_BOUNDED_PROMPT_TOKENS`, which is the measured size of
+     * a real A.4 prompt for a populated state — not an optimistic guess. It is
+     * overridable because the honest comparison depends on the spec and the
+     * state: a procedure with twenty schema fields costs more per step than one
+     * with two, and pretending otherwise would flatter the integration.
+     */
+    readonly boundedPromptTokens?: number;
+    /**
+     * Tokens of Σₜ, the state block inside the bounded prompt.
+     *
+     * Σₜ is not free — it grows with what the agent records — so a paper prompt
+     * is not literally constant. Including it separately, rather than folding it
+     * into the constant, keeps that growth visible instead of hidden inside a
+     * number that looks flat.
+     */
+    readonly stateTokens?: number;
+    /**
+     * What a cache read costs relative to a fresh input token.
+     *
+     * Defaults to {@link DEFAULT_CACHE_READ_DISCOUNT}. Overridable because the
+     * real multiplier is the provider's, and a number nobody can change is a
+     * number nobody should trust.
+     */
+    readonly cacheReadDiscount?: number;
+}
+/**
+ * Measured A.4 prompt size for a populated state, in tokens.
+ *
+ * 1 800 is the paper's own Table 1 figure and is close to what
+ * `PromptTransformer.formatPaper` produces for a realistic spec: instructions
+ * plus a compact state block plus a short observation. It is a DEFAULT, and
+ * `reconstruct` takes an override, precisely so nobody quotes it as our
+ * measurement of anything.
+ */
+export declare const DEFAULT_BOUNDED_PROMPT_TOKENS = 1800;
+/** A real session's per-step token accounting. */
+export interface HostSession {
+    readonly sessionID: string;
+    /** Title or task description, for the report. */
+    readonly label: string;
+    /** Ordered per-step usage, exactly as the host recorded it. */
+    readonly steps: readonly StepUsage[];
+}
+/** The two curves, and what they cost. */
+export interface ReconstructResult {
+    readonly sessionID: string;
+    readonly label: string;
+    /** Number of steps replayed. */
+    readonly steps: number;
+    /** What the host actually spent on prompts, summed. */
+    readonly hostPromptTokens: number;
+    /** What bounded Aₜ prompts would have cost, summed. */
+    readonly boundedPromptTokens: number;
+    /** `host − bounded`, summed. Negative means the transcript was cheaper. */
+    readonly savedTokens: number;
+    /** `saved / host`, as a fraction. Null when the host spent nothing. */
+    readonly savedFraction: number | null;
+    /** Fresh, uncached input tokens the host charged for. */
+    readonly freshInputTokens: number;
+    /** Cache-read tokens the host charged for. */
+    readonly cacheReadTokens: number;
+    /**
+     * The session priced in input-equivalent tokens, with cache reads
+     * discounted.
+     *
+     * The honest denominator. `hostPromptTokens` adds a cache read to a fresh
+     * input as if they cost the same, which they do not, and a token saving
+     * quoted from that sum is inflated by roughly an order of magnitude on a
+     * cache-heavy corpus.
+     */
+    readonly hostEffectiveTokens: number;
+    /**
+     * The saving priced properly: `(effective − bounded) / effective`.
+     *
+     * Always smaller than {@link savedFraction}, and the one to quote.
+     */
+    readonly savedEffectiveFraction: number | null;
+    /** Host prompt tokens per step, in order. */
+    readonly hostPerStep: readonly number[];
+    /** Bounded prompt tokens per step, in order. */
+    readonly boundedPerStep: readonly number[];
+    /**
+     * How much the host's per-step prompt grew across the session.
+     *
+     * This is the O(T) signature: a bounded prompt has a near-zero slope, and a
+     * transcript's slope is the entire cost of the next hundred steps.
+     */
+    readonly hostSlope: number;
+    /** The same slope for the bounded prompt. Expected to be 0. */
+    readonly boundedSlope: number;
+    /** The effect size in MADs, for comparison against the noise floor. */
+    readonly effect: EffectSize;
+    /** Host and bounded distributions, for the report. */
+    readonly distributions: {
+        readonly host: Distribution;
+        readonly bounded: Distribution;
+    };
+}
+/** Total prompt tokens for one step: fresh input plus cache reads. */
+export declare function freshInputTokens(session: HostSession): number;
+/** Total cache-read tokens for a session. */
+export declare function cacheReadTokens(session: HostSession): number;
+/**
+ * Compare a real session's transcript cost against a bounded prompt.
+ *
+ * Pure arithmetic over the host's own numbers. No model, no network, no clock
+ * — which is what makes it runnable when the quota is exhausted, and what
+ * makes it deterministic enough to assert on in a test.
+ */
+export declare function reconstruct(session: HostSession, options?: ReconstructOptions): ReconstructResult;
+/**
+ * Whether a reconstruction is strong enough to act on.
+ *
+ * The same discipline as the A/B gates, applied to the offline path. A
+ * one-step session, or one whose transcript never grew, cannot distinguish
+ * the two curves — and a saving computed from a flat transcript is an artifact
+ * of the constant, not a result.
+ */
+export declare function assessReconstruction(result: ReconstructResult): {
+    readonly usable: boolean;
+    readonly reasons: readonly string[];
+};
+//# sourceMappingURL=replay.d.ts.map

package/dist/ab/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../src/ab/replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEhE,sEAAsE;AACtE,MAAM,WAAW,SAAS;IACxB,oCAAoC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,qBAAqB;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAE/C,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAEtD;AAED,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;OAQG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAElD,kDAAkD;AAClD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;CACtC;AAED,0CAA0C;AAC1C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,uDAAuD;IACvD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,yDAAyD;IACzD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,8CAA8C;IAC9C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;;;;;OAQG;IACH,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC;;;;OAIG;IACH,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,6CAA6C;IAC7C,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,gDAAgD;IAChD,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,sDAAsD;IACtD,QAAQ,CAAC,aAAa,EAAE;QACtB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;QAC5B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;KAChC,CAAC;CACH;AAED,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE7D;AAED,6CAA6C;AAC7C,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE5D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,kBAAuB,GAC/B,iBAAiB,CA6CnB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG;IAC/D,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC,CAiBA"}

package/dist/ab/replay.js

@@ -0,0 +1,149 @@
+/**
+ * Reconstructing the host's token curve, and what a bounded prompt would cost.
+ *
+ * ── Why this exists, given the A/B harness ───────────────────────────────
+ *
+ * The harness answers "does the integration save tokens, on a live host". That
+ * question needs a live host, and the account quota is currently negative, so
+ * it cannot be answered today by running more experiments.
+ *
+ * This module answers a different and much narrower question that needs no
+ * model at all: **given a real session's real token accounting, what would a
+ * bounded Aₜ = (P, Σₜ, Oₜ) prompt have cost on those same steps?**
+ *
+ * That is not a substitute for the A/B, and the difference matters:
+ *
+ * - the A/B measures whether an agent, given a bounded prompt, still does the
+ *   work — an outcome question this cannot touch;
+ * - this measures the COST side only, using token counts the host itself
+ *   recorded, with no model in the loop.
+ *
+ * Both are needed. A cost win with no task completion is worthless, and a task
+ * completion with no cost win is not the claim the paper makes. This module
+ * deliberately reports the half it can actually measure, and refuses to
+ * extrapolate to the half it cannot.
+ *
+ * ── Where the numbers come from ──────────────────────────────────────────
+ *
+ * OpenCode records per-message `tokens` — `input`, `cache.read`,
+ * `cache.write`, `output`, `reasoning` — in its own store. Those are the
+ * host's own accounting for a real session, not our reconstruction of it.
+ *
+ * `cache.read` is the interesting one, and the reason this is not a
+ * hypothetical. A growing transcript does not merely cost more to send: the
+ * host caches the prefix, so the re-sent history is billed as cache reads.
+ * Ignoring them would report a saving of a few percent and hide the actual
+ * shape of the cost.
+ *
+ * @non-paper — measurement infrastructure, not the paper's evaluation.
+ */
+import { describe, effectSize, MIN_EFFECT_IN_MADS } from './stats-core.js';
+/**
+ * What a cache read is worth relative to a fresh input token.
+ *
+ * `1/10` is the usual published rate for prompt caching, and it is a DEFAULT,
+ * not a measurement: the real multiplier is the provider's, and this repo has
+ * no access to anyone's invoice. The number exists because adding `cache.read`
+ * to `input` at face value is the single easiest way to overstate a token
+ * saving, and that is worth a knob rather than a silent assumption.
+ *
+ * A cache read is NOT free: the model is shown the same text either way, and
+ * the paper's claim is about what the model is exposed to. The discount
+ * reflects PRICE, not attention.
+ */
+export const DEFAULT_CACHE_READ_DISCOUNT = 0.1;
+/** Fresh input plus cache reads, i.e. everything the model was shown. */
+export function promptTokensOf(step) {
+    return step.input + step.cacheRead;
+}
+/**
+ * Measured A.4 prompt size for a populated state, in tokens.
+ *
+ * 1 800 is the paper's own Table 1 figure and is close to what
+ * `PromptTransformer.formatPaper` produces for a realistic spec: instructions
+ * plus a compact state block plus a short observation. It is a DEFAULT, and
+ * `reconstruct` takes an override, precisely so nobody quotes it as our
+ * measurement of anything.
+ */
+export const DEFAULT_BOUNDED_PROMPT_TOKENS = 1800;
+/** Total prompt tokens for one step: fresh input plus cache reads. */
+export function freshInputTokens(session) {
+    return session.steps.reduce((sum, step) => sum + step.input, 0);
+}
+/** Total cache-read tokens for a session. */
+export function cacheReadTokens(session) {
+    return session.steps.reduce((sum, step) => sum + step.cacheRead, 0);
+}
+/**
+ * Compare a real session's transcript cost against a bounded prompt.
+ *
+ * Pure arithmetic over the host's own numbers. No model, no network, no clock
+ * — which is what makes it runnable when the quota is exhausted, and what
+ * makes it deterministic enough to assert on in a test.
+ */
+export function reconstruct(session, options = {}) {
+    const stateTokens = options.stateTokens ?? 0;
+    const perStepBounded = (options.boundedPromptTokens ?? DEFAULT_BOUNDED_PROMPT_TOKENS) + stateTokens;
+    const hostPerStep = session.steps.map(promptTokensOf);
+    const boundedPerStep = session.steps.map(() => perStepBounded);
+    const hostPromptTokens = hostPerStep.reduce((a, b) => a + b, 0);
+    const boundedPromptTokens = boundedPerStep.reduce((a, b) => a + b, 0);
+    const savedTokens = hostPromptTokens - boundedPromptTokens;
+    const fresh = freshInputTokens(session);
+    const cached = cacheReadTokens(session);
+    const discount = options.cacheReadDiscount ?? DEFAULT_CACHE_READ_DISCOUNT;
+    // What the session cost in INPUT-EQUIVALENT tokens: cache reads are counted
+    // at their price, not at face value. This is the number that survives a
+    // billing argument; the raw total does not.
+    const hostEffectiveTokens = fresh + cached * discount;
+    return {
+        sessionID: session.sessionID,
+        label: session.label,
+        steps: session.steps.length,
+        hostPromptTokens,
+        boundedPromptTokens,
+        savedTokens,
+        savedFraction: hostPromptTokens === 0 ? null : savedTokens / hostPromptTokens,
+        freshInputTokens: fresh,
+        cacheReadTokens: cached,
+        hostEffectiveTokens,
+        savedEffectiveFraction: hostEffectiveTokens === 0
+            ? null
+            : (hostEffectiveTokens - boundedPromptTokens) / hostEffectiveTokens,
+        hostPerStep,
+        boundedPerStep,
+        // Slope across the whole session: last step minus first. A transcript's
+        // growth is the story; the total alone averages it away.
+        hostSlope: hostPerStep.length < 2 ? 0 : hostPerStep[hostPerStep.length - 1] - hostPerStep[0],
+        boundedSlope: boundedPerStep.length < 2 ? 0 : boundedPerStep[boundedPerStep.length - 1] - boundedPerStep[0],
+        // Signed so a positive effect means the transcript cost more.
+        effect: effectSize(hostPerStep, boundedPerStep),
+        distributions: {
+            host: describe(hostPerStep),
+            bounded: describe(boundedPerStep),
+        },
+    };
+}
+/**
+ * Whether a reconstruction is strong enough to act on.
+ *
+ * The same discipline as the A/B gates, applied to the offline path. A
+ * one-step session, or one whose transcript never grew, cannot distinguish
+ * the two curves — and a saving computed from a flat transcript is an artifact
+ * of the constant, not a result.
+ */
+export function assessReconstruction(result) {
+    const reasons = [];
+    if (result.steps < 2) {
+        reasons.push('a single step cannot show growth; need at least 2');
+    }
+    if (result.hostSlope <= 0) {
+        reasons.push('the transcript did not grow across the session, so there is no O(T) cost to remove; ' +
+            'this session is too short or too uniform to distinguish the two curves');
+    }
+    if (result.effect.inMads !== null && Math.abs(result.effect.inMads) < MIN_EFFECT_IN_MADS) {
+        reasons.push(`the gap is ${result.effect.inMads.toFixed(2)} MADs, under the ${MIN_EFFECT_IN_MADS} needed to call it a signal`);
+    }
+    return { usable: reasons.length === 0, reasons };
+}
+//# sourceMappingURL=replay.js.map

package/dist/ab/replay.js.map

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

package/dist/ab/report.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Rendering a verdict for a human reader.
+ *
+ * ── The formatting rule that matters ─────────────────────────────────────
+ *
+ * A percentage is printed on exactly two paths: a `saving` and a
+ * `regression`. Every refusal prints the gates instead, because a reader
+ * shown "39% saved" and a reader shown "INERT: the state file was never
+ * written" take completely different actions, and only one of them is
+ * correct.
+ *
+ * @non-paper — measurement infrastructure, not the paper's evaluation.
+ */
+import type { ArmId, ArmRecord } from './record.js';
+import type { VerdictResult } from './verdict.js';
+/**
+ * A per-arm table: n, median, spread, and engagement.
+ *
+ * The engagement column is not decoration. It is the fastest way for a reader
+ * to see that an arm measured nothing, and it is the column whose absence
+ * produced the original false positive.
+ */
+export declare function formatArmTable(arms: ReadonlyMap<ArmId, ArmRecord>): string;
+/** The full human-readable report for one experiment. */
+export declare function formatVerdict(result: VerdictResult, table: string): string;
+//# sourceMappingURL=report.d.ts.map

package/dist/ab/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../src/ab/report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAgBlD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,MAAM,CAwB1E;AAiBD,yDAAyD;AACzD,wBAAgB,aAAa,CAC3B,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,MAAM,GACZ,MAAM,CA0BR"}

package/dist/ab/report.js

@@ -0,0 +1,98 @@
+/**
+ * Rendering a verdict for a human reader.
+ *
+ * ── The formatting rule that matters ─────────────────────────────────────
+ *
+ * A percentage is printed on exactly two paths: a `saving` and a
+ * `regression`. Every refusal prints the gates instead, because a reader
+ * shown "39% saved" and a reader shown "INERT: the state file was never
+ * written" take completely different actions, and only one of them is
+ * correct.
+ *
+ * @non-paper — measurement infrastructure, not the paper's evaluation.
+ */
+import { promptTokens } from './record.js';
+import { describe } from './stats-core.js';
+const HEADLINE = {
+    saving: 'SAVING',
+    regression: 'REGRESSION',
+    'no-effect': 'NO-EFFECT',
+    inert: 'INERT',
+    'not-comparable': 'NOT-COMPARABLE',
+    invalid: 'INVALID',
+};
+/** Left-pad a label to a fixed width so the table stays aligned. */
+function cell(text, width) {
+    return text.length >= width ? text : text + ' '.repeat(width - text.length);
+}
+/**
+ * A per-arm table: n, median, spread, and engagement.
+ *
+ * The engagement column is not decoration. It is the fastest way for a reader
+ * to see that an arm measured nothing, and it is the column whose absence
+ * produced the original false positive.
+ */
+export function formatArmTable(arms) {
+    const rows = [
+        ['arm', 'n', 'prompt median', 'MAD', 'spread', 'state writes', 'turns']
+            .map((h) => cell(h, 13))
+            .join(' '),
+    ];
+    for (const [arm, record] of arms) {
+        const promptTokensSeen = record.runs.map((run) => promptTokens(run.usage));
+        const distribution = armDistribution(promptTokensSeen);
+        const writes = record.runs.reduce((n, run) => n + run.engagement.writes, 0);
+        const turns = record.runs.reduce((n, run) => n + run.work.turns, 0);
+        rows.push([
+            cell(arm, 13),
+            cell(String(distribution.n), 13),
+            cell(String(distribution.median), 13),
+            cell(String(distribution.mad), 13),
+            cell(`±${(distribution.relativeMad * 100).toFixed(0)}%`, 13),
+            cell(String(writes), 13),
+            cell(String(turns), 13),
+        ].join(' '));
+    }
+    return rows.join('\n');
+}
+/**
+ * Distribution of one arm, tolerating an arm with no runs.
+ *
+ * `describe` throws on an empty sample, which is the right behaviour for a
+ * gate that must not compare an unrun arm. A table is a different contract:
+ * a diagnostic that crashes on the arm it is meant to diagnose is useless,
+ * so an absent arm renders as zeros here. The gate still refuses the run.
+ */
+function armDistribution(values) {
+    if (values.length === 0) {
+        return { n: 0, min: 0, median: 0, max: 0, mad: 0, relativeMad: 0, sorted: [] };
+    }
+    return describe(values);
+}
+/** The full human-readable report for one experiment. */
+export function formatVerdict(result, table) {
+    const lines = [table, ''];
+    const measured = result.verdict === 'saving' || result.verdict === 'regression';
+    if (measured && result.effect !== null) {
+        const relative = result.effect.relative === null
+            ? 'n/a (control median is 0)'
+            : `${(result.effect.relative * 100).toFixed(1)}%`;
+        lines.push(`${HEADLINE[result.verdict]}: ${relative} of prompt tokens ` +
+            `(${result.effect.difference > 0 ? '' : '+'}${result.effect.difference} tokens at the median)` +
+            (result.effect.inMads === null
+                ? ', exact (both arms had zero spread)'
+                : `, ${Math.abs(result.effect.inMads).toFixed(1)} MADs`));
+    }
+    else {
+        lines.push(`${HEADLINE[result.verdict]}: no effect size reported.`);
+    }
+    if (result.failures.length > 0) {
+        lines.push('');
+        lines.push('Gates that fired:');
+        for (const failure of result.failures) {
+            lines.push(`  - [${failure.gate}] ${failure.detail}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=report.js.map

package/dist/ab/report.js.map

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