@skillstate/bench 3.0.0 → 3.0.1

package/dist/ab/stats-core.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Distribution summaries for a set of runs.
+ *
+ * ── Why the median and not the mean ──────────────────────────────────────
+ *
+ * Run-to-run variance in a non-deterministic host is large — the old A/B
+ * measured the same arm twice and got 42 364 and 71 590 input tokens, a 69%
+ * swing between a mid-run reading and the final one. A mean over a handful
+ * of such samples is dominated by whichever sample was luckiest, and a
+ * percentage computed from it inherits that luck.
+ *
+ * The median is reported instead, together with the median absolute
+ * deviation (MAD), so a reader sees the SPREAD next to the effect. An effect
+ * smaller than the spread is not an effect, and the harness in `verdict.ts`
+ * refuses to call it one.
+ *
+ * These are deliberately dependency-free and deterministic: same input, same
+ * output, no RNG anywhere. That is what lets the gates be tested against the
+ * real historical numbers.
+ *
+ * @non-paper — measurement infrastructure, not the paper's evaluation.
+ */
+/**
+ * Median of a non-empty numeric sample.
+ *
+ * Requires a non-empty array and throws on an empty one: an empty sample has
+ * no median, and inventing one (0, or NaN) would let a silently-unrun arm
+ * compare as if it had run. The gates validate sample size before calling.
+ */
+export declare function median(values: readonly number[]): number;
+/**
+ * Median absolute deviation — a spread measure that ignores outliers.
+ *
+ * Subtracting the median first is what makes it robust: one runaway run
+ * inflates a standard deviation enough to hide a real effect, but barely
+ * moves the MAD, because the runaway run's own deviation is measured against
+ * a median that the median itself did not follow.
+ */
+export declare function mad(values: readonly number[]): number;
+/** The spread of a sample, as a fraction of its median. Zero when the median is 0. */
+export declare function relativeMad(values: readonly number[]): number;
+/** A sample summarised for reporting. */
+export interface Distribution {
+    readonly n: number;
+    readonly min: number;
+    readonly median: number;
+    readonly max: number;
+    /** Median absolute deviation, in the same units as the sample. */
+    readonly mad: number;
+    /** MAD as a fraction of the median. 0 when the median is 0. */
+    readonly relativeMad: number;
+    /** The raw values, sorted ascending, so a reader can check the summary. */
+    readonly sorted: readonly number[];
+}
+/** Summarise a sample. Throws on an empty one — see {@link median}. */
+export declare function describe(values: readonly number[]): Distribution;
+/**
+ * A relative effect size, robust to scale and to spread.
+ *
+ * `effect = (control − instrumented) / pooledSpread`, where `pooledSpread` is
+ * the larger of the two arms' MADs. The sign carries the direction (positive
+ * means the instrumented arm spent fewer prompt tokens); the magnitude is the
+ * number of MADs the gap is worth.
+ *
+ * When both arms have zero spread the comparison is exact and the ratio is
+ * undefined, so `exact: true` is returned with the plain difference. Callers
+ * must branch on `exact` rather than dividing by the missing ratio — that
+ * branch is where a harness quietly invents an effect.
+ */
+export interface EffectSize {
+    /** False when either arm had zero spread and the ratio cannot be formed. */
+    readonly exact: boolean;
+    /** `control − instrumented`, in tokens. Positive favours the instrumented arm. */
+    readonly difference: number;
+    /** Difference as a fraction of the control median. Null when the median is 0. */
+    readonly relative: number | null;
+    /** Difference in units of pooled MAD. Null when `exact` is false. */
+    readonly inMads: number | null;
+}
+/** Minimum effect, in MADs, the harness is willing to call a signal. */
+export declare const MIN_EFFECT_IN_MADS = 1;
+/** Compare two arms' prompt-token distributions. Throws if either sample is empty. */
+export declare function effectSize(control: readonly number[], instrumented: readonly number[]): EffectSize;
+//# sourceMappingURL=stats-core.d.ts.map

package/dist/ab/stats-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats-core.d.ts","sourceRoot":"","sources":["../../src/ab/stats-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CASxD;AAED;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMrD;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAG7D;AAED,yCAAyC;AACzC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAchE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IACzB,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC,sFAAsF;AACtF,wBAAgB,UAAU,CACxB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,UAAU,CAcZ"}

package/dist/ab/stats-core.js

@@ -0,0 +1,93 @@
+/**
+ * Distribution summaries for a set of runs.
+ *
+ * ── Why the median and not the mean ──────────────────────────────────────
+ *
+ * Run-to-run variance in a non-deterministic host is large — the old A/B
+ * measured the same arm twice and got 42 364 and 71 590 input tokens, a 69%
+ * swing between a mid-run reading and the final one. A mean over a handful
+ * of such samples is dominated by whichever sample was luckiest, and a
+ * percentage computed from it inherits that luck.
+ *
+ * The median is reported instead, together with the median absolute
+ * deviation (MAD), so a reader sees the SPREAD next to the effect. An effect
+ * smaller than the spread is not an effect, and the harness in `verdict.ts`
+ * refuses to call it one.
+ *
+ * These are deliberately dependency-free and deterministic: same input, same
+ * output, no RNG anywhere. That is what lets the gates be tested against the
+ * real historical numbers.
+ *
+ * @non-paper — measurement infrastructure, not the paper's evaluation.
+ */
+/**
+ * Median of a non-empty numeric sample.
+ *
+ * Requires a non-empty array and throws on an empty one: an empty sample has
+ * no median, and inventing one (0, or NaN) would let a silently-unrun arm
+ * compare as if it had run. The gates validate sample size before calling.
+ */
+export function median(values) {
+    if (values.length === 0) {
+        throw new RangeError('median of an empty sample is undefined');
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = sorted.length >> 1;
+    return sorted.length % 2 === 1
+        ? sorted[middle]
+        : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+/**
+ * Median absolute deviation — a spread measure that ignores outliers.
+ *
+ * Subtracting the median first is what makes it robust: one runaway run
+ * inflates a standard deviation enough to hide a real effect, but barely
+ * moves the MAD, because the runaway run's own deviation is measured against
+ * a median that the median itself did not follow.
+ */
+export function mad(values) {
+    if (values.length === 0) {
+        throw new RangeError('MAD of an empty sample is undefined');
+    }
+    const center = median(values);
+    return median(values.map((value) => Math.abs(value - center)));
+}
+/** The spread of a sample, as a fraction of its median. Zero when the median is 0. */
+export function relativeMad(values) {
+    const center = median(values);
+    return center === 0 ? 0 : mad(values) / center;
+}
+/** Summarise a sample. Throws on an empty one — see {@link median}. */
+export function describe(values) {
+    if (values.length === 0) {
+        throw new RangeError('cannot describe an empty sample');
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    return {
+        n: values.length,
+        min: sorted[0],
+        median: median(values),
+        max: sorted[sorted.length - 1],
+        mad: mad(values),
+        relativeMad: relativeMad(values),
+        sorted,
+    };
+}
+/** Minimum effect, in MADs, the harness is willing to call a signal. */
+export const MIN_EFFECT_IN_MADS = 1;
+/** Compare two arms' prompt-token distributions. Throws if either sample is empty. */
+export function effectSize(control, instrumented) {
+    if (control.length === 0 || instrumented.length === 0) {
+        throw new RangeError('effect size needs a non-empty sample in both arms');
+    }
+    const controlMedian = median(control);
+    const instrumentedMedian = median(instrumented);
+    const difference = controlMedian - instrumentedMedian;
+    const relative = controlMedian === 0 ? null : difference / controlMedian;
+    const spread = Math.max(mad(control), mad(instrumented));
+    if (spread === 0) {
+        return { exact: true, difference, relative, inMads: null };
+    }
+    return { exact: false, difference, relative, inMads: difference / spread };
+}
+//# sourceMappingURL=stats-core.js.map

package/dist/ab/stats-core.js.map

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

package/dist/ab/survey.d.ts

@@ -0,0 +1,131 @@
+/**
+ * A survey over a real host's own session store.
+ *
+ * ── What this measures, and what it does not ──────────────────────────────
+ *
+ * It answers ONE question, on real data, with no model in the loop:
+ *
+ *   *given a real session's real token accounting, what would a bounded
+ *   Aₜ = (P, Σₜ, Oₜ) prompt have cost on those same steps?*
+ *
+ * It does NOT answer whether an agent given that bounded prompt still does the
+ * work. That is an outcome question, it needs a live model, and no amount of
+ * offline arithmetic substitutes for it. A survey that reported a saving as if
+ * it established the claim would be repeating the original error with extra
+ * steps — the original A/B reported a number for a run whose integration had
+ * never engaged, and a cost-only win with no task completion is worth nothing.
+ *
+ * The two halves are complementary: this establishes that the cost side is
+ * real and large, the A/B establishes that the work still gets done.
+ *
+ * ── Why the host's own store ─────────────────────────────────────────────
+ *
+ * OpenCode records per-message `tokens` — `input`, `cache.read`, `output`,
+ * `reasoning`. Reading them means the numbers are the host's accounting for a
+ * real session rather than our reconstruction of it, and it works with no live
+ * model, which is what makes it usable when a provider quota is exhausted.
+ *
+ * `cache.read` is the field that carries the finding. A growing transcript is
+ * not merely expensive to send: the host caches the prefix, so re-reading
+ * history is billed as cache reads. Counting only fresh `input` would report a
+ * few percent and miss the entire effect.
+ *
+ * @non-paper — measurement infrastructure, not the paper's evaluation.
+ */
+import { assessReconstruction, reconstruct } from './replay.js';
+import type { HostSession, ReconstructResult, StepUsage } from './replay.js';
+/** The result of surveying a set of sessions. */
+export interface Survey {
+    /** Sessions with enough steps to compare curves. */
+    readonly sessions: number;
+    /** Total steps across every session. */
+    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. */
+    readonly savedTokens: number;
+    /** `saved / host`, as a raw token count. Inflated; see {@link savedEffectiveFraction}. */
+    readonly savedFraction: number | null;
+    /** Fresh, uncached input tokens across the corpus. */
+    readonly freshInputTokens: number;
+    /** Cache-read tokens across the corpus. */
+    readonly cacheReadTokens: number;
+    /** Cache reads as a share of all prompt tokens. */
+    readonly cacheShare: number;
+    /**
+     * The corpus priced in input-equivalent tokens, cache reads discounted.
+     *
+     * The number to quote. The raw total counts a cache read as equal to a
+     * fresh input token, and on a cache-heavy corpus that inflates a saving by
+     * roughly an order of magnitude.
+     */
+    readonly hostEffectiveTokens: number;
+    /**
+     * The saving priced properly. Always ≤ {@link savedFraction}, and the
+     * defensible one.
+     */
+    readonly savedEffectiveFraction: number | null;
+    /** Per-session saving fractions, for a median. */
+    readonly perSession: readonly number[];
+    /** Median per-session saving. */
+    readonly medianSavedFraction: number;
+    /** Sessions whose prompt grew between first and last step. */
+    readonly grewCount: number;
+    /**
+     * Sessions where the bounded prompt would have cost MORE.
+     *
+     * The strongest number in the survey: a bounded prompt that never loses is
+     * a different claim from one that usually wins, and only the counter can
+     * distinguish them.
+     *
+     * CAVEAT when quoting it: this counts every session, including rows that
+     * recorded zero tokens — aborted runs and records written before
+     * accounting was populated. Such a session is not "a run that came out
+     * cheap", it is a run that never happened, and it will register as a loss
+     * for any bounded prompt. Filter on {@link spentSessions} before claiming
+     * "never loses", or the number is smaller and more honest.
+     */
+    readonly boundedLosesCount: number;
+    /** Sessions where the host recorded any token spend at all. */
+    readonly spentSessions: number;
+    /** Per-session results, largest saving first. */
+    readonly results: readonly ReconstructResult[];
+}
+/** Options for {@link survey}. */
+export interface SurveyOptions {
+    /** Tokens per bounded Aₜ prompt. Defaults to the paper's ~1.8k. */
+    readonly boundedPromptTokens?: number;
+    /** Include a session's full per-step arrays in `results`. Defaults to false. */
+    readonly keepPerStep?: boolean;
+}
+/**
+ * Survey many sessions at once.
+ *
+ * Aggregates rather than averaging the per-session percentages: a 1123-step
+ * session and a 3-step session must not count equally, and taking a mean of
+ * ratios would let the many short cheap sessions drown the few long expensive
+ * ones that carry the finding.
+ */
+export declare function survey(sessions: readonly HostSession[], options?: SurveyOptions): Survey;
+/**
+ * How large a bounded prompt may be before it stops being the cheaper option.
+ *
+ * The honest way to state the finding: not "a bounded prompt saves 99%", but
+ * "a bounded prompt of up to N tokens per step is cheaper in EVERY session
+ * measured". N is a property of the data, not a number chosen to look good.
+ */
+export declare function breakEvenPromptTokens(sessions: readonly HostSession[]): {
+    /** Tokens per step below which bounded wins in every session. */
+    readonly tokens: number;
+    /** True when that bound came from the worst session, not the median. */
+    readonly conservative: boolean;
+    /** The average host prompt per step, for context. */
+    readonly medianAverage: number;
+};
+/** Render a survey as a human-readable block. */
+export declare function formatSurvey(surveyResult: Survey): string;
+export { assessReconstruction, reconstruct };
+export type { HostSession, ReconstructResult, StepUsage };
+//# sourceMappingURL=survey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"survey.d.ts","sourceRoot":"","sources":["../../src/ab/survey.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7E,iDAAiD;AACjD,MAAM,WAAW,MAAM;IACrB,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,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,gCAAgC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,0FAA0F;IAC1F,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,sDAAsD;IACtD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,2CAA2C;IAC3C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,mDAAmD;IACnD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC;;;OAGG;IACH,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,kDAAkD;IAClD,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,iCAAiC;IACjC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,+DAA+D;IAC/D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAChD;AAED,kCAAkC;AAClC,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,gFAAgF;IAChF,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CACpB,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,OAAO,GAAE,aAAkB,GAC1B,MAAM,CAyDR;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG;IACvE,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,qDAAqD;IACrD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,CAiBA;AAED,iDAAiD;AACjD,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAuBzD;AAED,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,CAAC;AAC7C,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,SAAS,EAAE,CAAC"}

package/dist/ab/survey.js

@@ -0,0 +1,143 @@
+/**
+ * A survey over a real host's own session store.
+ *
+ * ── What this measures, and what it does not ──────────────────────────────
+ *
+ * It answers ONE question, on real data, with no model in the loop:
+ *
+ *   *given a real session's real token accounting, what would a bounded
+ *   Aₜ = (P, Σₜ, Oₜ) prompt have cost on those same steps?*
+ *
+ * It does NOT answer whether an agent given that bounded prompt still does the
+ * work. That is an outcome question, it needs a live model, and no amount of
+ * offline arithmetic substitutes for it. A survey that reported a saving as if
+ * it established the claim would be repeating the original error with extra
+ * steps — the original A/B reported a number for a run whose integration had
+ * never engaged, and a cost-only win with no task completion is worth nothing.
+ *
+ * The two halves are complementary: this establishes that the cost side is
+ * real and large, the A/B establishes that the work still gets done.
+ *
+ * ── Why the host's own store ─────────────────────────────────────────────
+ *
+ * OpenCode records per-message `tokens` — `input`, `cache.read`, `output`,
+ * `reasoning`. Reading them means the numbers are the host's accounting for a
+ * real session rather than our reconstruction of it, and it works with no live
+ * model, which is what makes it usable when a provider quota is exhausted.
+ *
+ * `cache.read` is the field that carries the finding. A growing transcript is
+ * not merely expensive to send: the host caches the prefix, so re-reading
+ * history is billed as cache reads. Counting only fresh `input` would report a
+ * few percent and miss the entire effect.
+ *
+ * @non-paper — measurement infrastructure, not the paper's evaluation.
+ */
+import { assessReconstruction, reconstruct } from './replay.js';
+/**
+ * Survey many sessions at once.
+ *
+ * Aggregates rather than averaging the per-session percentages: a 1123-step
+ * session and a 3-step session must not count equally, and taking a mean of
+ * ratios would let the many short cheap sessions drown the few long expensive
+ * ones that carry the finding.
+ */
+export function survey(sessions, options = {}) {
+    const results = [];
+    for (const session of sessions) {
+        const result = reconstruct(session, {
+            ...(options.boundedPromptTokens === undefined
+                ? {}
+                : { boundedPromptTokens: options.boundedPromptTokens }),
+        });
+        results.push(options.keepPerStep === true
+            ? result
+            : { ...result, hostPerStep: [], boundedPerStep: [] });
+    }
+    const hostPromptTokens = results.reduce((sum, r) => sum + r.hostPromptTokens, 0);
+    const boundedPromptTokens = results.reduce((sum, r) => sum + r.boundedPromptTokens, 0);
+    const savedTokens = hostPromptTokens - boundedPromptTokens;
+    const freshInputTokens = results.reduce((sum, r) => sum + r.freshInputTokens, 0);
+    const cacheReadTokens = results.reduce((sum, r) => sum + r.cacheReadTokens, 0);
+    const hostEffectiveTokens = results.reduce((sum, r) => sum + r.hostEffectiveTokens, 0);
+    const perSession = results
+        .map((r) => r.savedFraction)
+        .filter((f) => f !== null)
+        .sort((a, b) => a - b);
+    const middle = perSession.length >> 1;
+    const medianSavedFraction = perSession.length === 0
+        ? 0
+        : perSession.length % 2 === 1
+            ? perSession[middle]
+            : (perSession[middle - 1] + perSession[middle]) / 2;
+    return {
+        sessions: results.length,
+        steps: results.reduce((sum, r) => sum + r.steps, 0),
+        hostPromptTokens,
+        boundedPromptTokens,
+        savedTokens,
+        savedFraction: hostPromptTokens === 0 ? null : savedTokens / hostPromptTokens,
+        freshInputTokens,
+        cacheReadTokens,
+        cacheShare: hostPromptTokens === 0 ? 0 : cacheReadTokens / hostPromptTokens,
+        hostEffectiveTokens,
+        savedEffectiveFraction: hostEffectiveTokens === 0
+            ? null
+            : (hostEffectiveTokens - boundedPromptTokens) / hostEffectiveTokens,
+        perSession,
+        medianSavedFraction,
+        grewCount: results.filter((r) => r.hostSlope > 0).length,
+        boundedLosesCount: results.filter((r) => r.savedTokens < 0).length,
+        spentSessions: results.filter((r) => r.hostPromptTokens > 0).length,
+        results: [...results].sort((a, b) => b.savedTokens - a.savedTokens),
+    };
+}
+/**
+ * How large a bounded prompt may be before it stops being the cheaper option.
+ *
+ * The honest way to state the finding: not "a bounded prompt saves 99%", but
+ * "a bounded prompt of up to N tokens per step is cheaper in EVERY session
+ * measured". N is a property of the data, not a number chosen to look good.
+ */
+export function breakEvenPromptTokens(sessions) {
+    const averages = sessions
+        .filter((s) => s.steps.length > 0)
+        .map((s) => s.steps.reduce((sum, step) => sum + step.input + step.cacheRead, 0) / s.steps.length)
+        .sort((a, b) => a - b);
+    if (averages.length === 0) {
+        return { tokens: 0, conservative: true, medianAverage: 0 };
+    }
+    const middle = averages.length >> 1;
+    return {
+        tokens: Math.floor(averages[0]),
+        conservative: true,
+        medianAverage: averages.length % 2 === 1
+            ? averages[middle]
+            : (averages[middle - 1] + averages[middle]) / 2,
+    };
+}
+/** Render a survey as a human-readable block. */
+export function formatSurvey(surveyResult) {
+    const pct = (value) => value === null ? 'n/a' : `${(value * 100).toFixed(1)}%`;
+    return [
+        `sessions            : ${surveyResult.sessions}`,
+        `steps total         : ${surveyResult.steps.toLocaleString('en-US')}`,
+        '',
+        '  raw token count (inflated - counts a cache read as a fresh input):',
+        `    fresh input      : ${surveyResult.freshInputTokens.toLocaleString('en-US')}`,
+        `    cache read       : ${surveyResult.cacheReadTokens.toLocaleString('en-US')} (${(surveyResult.cacheShare * 100).toFixed(1)}% of prompts)`,
+        `    host total       : ${surveyResult.hostPromptTokens.toLocaleString('en-US')}`,
+        `    bounded A_t      : ${surveyResult.boundedPromptTokens.toLocaleString('en-US')}`,
+        `    raw saving       : ${pct(surveyResult.savedFraction)}`,
+        '',
+        '  priced in input-equivalent tokens (cache reads discounted) - QUOTE THIS:',
+        `    host effective   : ${Math.round(surveyResult.hostEffectiveTokens).toLocaleString('en-US')}`,
+        `    bounded A_t      : ${surveyResult.boundedPromptTokens.toLocaleString('en-US')}`,
+        `    real saving      : ${pct(surveyResult.savedEffectiveFraction)}`,
+        '',
+        `median per session  : ${pct(surveyResult.medianSavedFraction)}`,
+        `transcript grew     : ${surveyResult.grewCount}/${surveyResult.sessions}`,
+        `bounded loses       : ${surveyResult.boundedLosesCount}/${surveyResult.spentSessions} real runs`,
+    ].join('\n');
+}
+export { assessReconstruction, reconstruct };
+//# sourceMappingURL=survey.js.map

package/dist/ab/survey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"survey.js","sourceRoot":"","sources":["../../src/ab/survey.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAuEhE;;;;;;;GAOG;AACH,MAAM,UAAU,MAAM,CACpB,QAAgC,EAChC,OAAO,GAAkB,EAAE;IAE3B,MAAM,OAAO,GAAwB,EAAE,CAAC;IACxC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,WAAW,CAAC,OAAO,EAAE;YAClC,GAAG,CAAC,OAAO,CAAC,mBAAmB,KAAK,SAAS;gBAC3C,CAAC,CAAC,EAAE;gBACJ,CAAC,CAAC,EAAE,mBAAmB,EAAE,OAAO,CAAC,mBAAmB,EAAE,CAAC;SAC1D,CAAC,CAAC;QACH,OAAO,CAAC,IAAI,CACV,OAAO,CAAC,WAAW,KAAK,IAAI;YAC1B,CAAC,CAAC,MAAM;YACR,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,WAAW,EAAE,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,CACvD,CAAC;IACJ,CAAC;IAED,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;IACjF,MAAM,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;IACvF,MAAM,WAAW,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;IAC3D,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;IACjF,MAAM,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;IAC/E,MAAM,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;IACvF,MAAM,UAAU,GAAG,OAAO;SACvB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;SAC3B,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC;SACtC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,IAAI,CAAC,CAAC;IACtC,MAAM,mBAAmB,GACvB,UAAU,CAAC,MAAM,KAAK,CAAC;QACrB,CAAC,CAAC,CAAC;QACH,CAAC,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC;YAC3B,CAAC,CAAC,UAAU,CAAC,MAAM,CAAE;YACrB,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAE,GAAG,UAAU,CAAC,MAAM,CAAE,CAAC,GAAG,CAAC,CAAC;IAE5D,OAAO;QACL,QAAQ,EAAE,OAAO,CAAC,MAAM;QACxB,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;QACnD,gBAAgB;QAChB,mBAAmB;QACnB,WAAW;QACX,aAAa,EAAE,gBAAgB,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,GAAG,gBAAgB;QAC7E,gBAAgB;QAChB,eAAe;QACf,UAAU,EAAE,gBAAgB,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,eAAe,GAAG,gBAAgB;QAC3E,mBAAmB;QACnB,sBAAsB,EACpB,mBAAmB,KAAK,CAAC;YACvB,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,CAAC,mBAAmB,GAAG,mBAAmB,CAAC,GAAG,mBAAmB;QACvE,UAAU;QACV,mBAAmB;QACnB,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,MAAM;QACxD,iBAAiB,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,MAAM;QAClE,aAAa,EAAE,OAAO,CAAC,MAAM,CAC3B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,gBAAgB,GAAG,CAAC,CAC9B,CAAC,MAAM;QACR,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC;KACpE,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAgC;IAQpE,MAAM,QAAQ,GAAG,QAAQ;SACtB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;SACjC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;SAChG,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC;IAC7D,CAAC;IACD,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC;IACpC,OAAO;QACL,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAE,CAAC;QAChC,YAAY,EAAE,IAAI;QAClB,aAAa,EACX,QAAQ,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC;YACvB,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAE;YACnB,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAE,GAAG,QAAQ,CAAC,MAAM,CAAE,CAAC,GAAG,CAAC;KACtD,CAAC;AACJ,CAAC;AAED,iDAAiD;AACjD,MAAM,UAAU,YAAY,CAAC,YAAoB;IAC/C,MAAM,GAAG,GAAG,CAAC,KAAoB,EAAU,EAAE,CAC3C,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC;IAC1D,OAAO;QACL,yBAAyB,YAAY,CAAC,QAAQ,EAAE;QAChD,yBAAyB,YAAY,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;QACrE,EAAE;QACF,sEAAsE;QACtE,0BAA0B,YAAY,CAAC,gBAAgB,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;QACjF,0BAA0B,YAAY,CAAC,eAAe,CAAC,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,UAAU,GAAG,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe;QAC5I,0BAA0B,YAAY,CAAC,gBAAgB,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;QACjF,0BAA0B,YAAY,CAAC,mBAAmB,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;QACpF,0BAA0B,GAAG,CAAC,YAAY,CAAC,aAAa,CAAC,EAAE;QAC3D,EAAE;QACF,4EAA4E;QAC5E,0BAA0B,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;QAChG,0BAA0B,YAAY,CAAC,mBAAmB,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;QACpF,0BAA0B,GAAG,CAAC,YAAY,CAAC,sBAAsB,CAAC,EAAE;QACpE,EAAE;QACF,yBAAyB,GAAG,CAAC,YAAY,CAAC,mBAAmB,CAAC,EAAE;QAChE,yBAAyB,YAAY,CAAC,SAAS,IAAI,YAAY,CAAC,QAAQ,EAAE;QAC1E,yBAAyB,YAAY,CAAC,iBAAiB,IAAI,YAAY,CAAC,aAAa,YAAY;KAClG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,CAAC"}

package/dist/ab/usage.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Token accounting read from the HOST's own store.
+ *
+ * ── Why not parse the host's stdout ──────────────────────────────────────
+ *
+ * Three reasons, in order of how much they matter:
+ *
+ * 1. **The model does not report its own cost reliably.** A harness that
+ *    takes the number the subject of the experiment wrote down is trusting the
+ *    measurement to the thing being measured. The previous A/B took its
+ *    figures from the run's own reporting, and one of its two "arms" was
+ *    itself two different readings of a single session.
+ * 2. **OpenCode already records per-message token usage** in its local store
+ *    (`message.data.tokens` with `input`, `output`, `reasoning` and
+ *    `cache.{read,write}`). That is the host's own accounting, not a
+ *    reconstruction, and it is keyed by session so a run can be re-read
+ *    after the fact.
+ * 3. **It is available without a live model.** Reading the store works when
+ *    the provider quota is exhausted, which is exactly when one most wants to
+ *    re-analyse a previous run.
+ *
+ * Node's `node:sqlite` is used rather than a dependency: the store is a
+ * local file, the read is a single prepared statement, and adding a native
+ * dependency to a zero-deps package for this would be a poor trade. The
+ * reader is injected, so the query and its failure modes are testable
+ * without an OpenCode installation.
+ *
+ * @non-paper — measurement infrastructure, not the paper's evaluation.
+ */
+import type { TokenUsage } from './record.js';
+/** One row of the host's message table, as far as this module cares. */
+export interface HostMessageRow {
+    /** The session the message belongs to. */
+    readonly sessionID: string;
+    /** Milliseconds since the epoch. */
+    readonly created: number;
+    /** `assistant`, `user`, or anything else this module ignores. */
+    readonly role: string;
+    /** Token accounting as the host recorded it. */
+    readonly tokens: Partial<TokenUsage> | null;
+}
+/**
+ * The narrow seam onto the host's store.
+ *
+ * Injecting this is what lets the arithmetic below be tested against
+ * hand-written rows instead of against a live OpenCode server, and what lets
+ * a caller substitute a different source (a JSON export, a CI fixture)
+ * without touching the logic that consumes it.
+ */
+export interface UsageReader {
+    /**
+     * Every message recorded for `sessionID`, in creation order.
+     *
+     * Rejects when the store is missing, locked, or the session is unknown —
+     * an unreadable store must surface as a failed run, never as zero tokens,
+     * because zero tokens would make an arm look free.
+     */
+    messagesFor(sessionID: string): Promise<readonly HostMessageRow[]>;
+}
+/** Zero usage, for a session whose messages carry no accounting. */
+export declare const NO_USAGE: TokenUsage;
+/**
+ * Total token spend for a session.
+ *
+ * Only `assistant` rows count. A user message's `input` figure is the host
+ * describing the prompt it echoed, and adding it would double-count the
+ * conversation.
+ *
+ * `cacheRead` is summed, not treated as free: prompt caching changes the
+ * price of a token, not the fact that the model was shown it, and the
+ * paper's claim is about what the model is exposed to.
+ */
+export declare function sessionUsage(rows: readonly HostMessageRow[]): TokenUsage;
+/** Why a usage lookup produced nothing. */
+export type UsageFailure = 
+/** The host store could not be opened or read. */
+'store_unavailable'
+/** The session id is not in the host's store. */
+ | 'session_unknown';
+/** The outcome of resolving one session's token spend. */
+export type UsageOutcome = {
+    readonly ok: true;
+    readonly usage: TokenUsage;
+    readonly assistantMessages: number;
+} | {
+    readonly ok: false;
+    readonly reason: UsageFailure;
+    readonly detail: string;
+};
+/**
+ * Resolve a session's token spend, turning every failure into a value.
+ *
+ * A run whose accounting cannot be read is a run with unknown cost, which is
+ * not the same as a run that cost nothing. The distinction is the whole
+ * reason this returns a union instead of a number: `store_unavailable` must
+ * never be silently read as `NO_USAGE`.
+ */
+export declare function resolveSessionUsage(reader: UsageReader, sessionID: string): Promise<UsageOutcome>;
+//# sourceMappingURL=usage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../src/ab/usage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,wEAAwE;AACxE,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oCAAoC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;CAC7C;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;OAMG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,cAAc,EAAE,CAAC,CAAC;CACpE;AAED,oEAAoE;AACpE,eAAO,MAAM,QAAQ,EAAE,UAKtB,CAAC;AAYF;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,cAAc,EAAE,GAAG,UAAU,CAaxE;AAED,2CAA2C;AAC3C,MAAM,MAAM,YAAY;AACtB,kDAAkD;AAChD,mBAAmB;AACrB,iDAAiD;GAC/C,iBAAiB,CAAC;AAEtB,0DAA0D;AAC1D,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,GACrF;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnF;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,YAAY,CAAC,CAoBvB"}