@mnemom/mnemom 0.17.6-next.0 → 0.17.6-next.2

package/dist/lib/agent.js

@@ -489,10 +489,175 @@ export const CONTEXT_HANDOFF_KEY = "CONTEXT_HANDOFF_ENABLED";
  *     `CLAUDE_CODE_AUTO_COMPACT_WINDOW` / `autoCompactWindow`) fires as it would without the fold;
  *   - `GATEWAY_COMPACTION_INTERCEPT` — answer the client's compaction request at once from the
  *     gateway's own fold digest (no model call), so the compaction never blocks the user.
- * Sent together, value `"on"`, ONLY when the setting is on (see `resolveCompactionIntercept`).
+ * Sent together, value `"on"`, when the `compaction_intercept` setting is on
+ * (`resolveCompactionIntercept`) OR when `--compact-at` arms a target below 1M (below) — a
+ * target cannot be honored without both.
  */
 export const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
 export const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
+// ---------------------------------------------------------------------------
+// Compaction target (`--compact-at`, launcher.toml `compact_at`, MNEMOM_COMPACT_AT)
+// ---------------------------------------------------------------------------
+//
+// Lets an operator play with WHEN the gateway pulls this session's own client-visible
+// compaction point forward (GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS, #2251), instead of
+// leaving Claude Code to compact on its own 1M-window schedule. Unset / `1m` / `off` all
+// mean the SAME thing — no target — so a launch with nothing else configured sends no new
+// header keys at all and behaves exactly as it did before this setting existed: Claude
+// Code's own 1M window, no gateway-triggered compaction. A value strictly below 1,000,000
+// arms the compaction intercept (USAGE_REAL_SIZE_KEY + COMPACTION_INTERCEPT_KEY, above — the
+// same two keys `--compaction-intercept` arms, #2216, both required for the upload pull to be
+// honored instead of silently inert) plus the target itself. Refold (GATEWAY_COMPACTION_REFOLD)
+// is a SEPARATE, costlier opt-in (+9.5pts measured) — this setting never touches it. This never
+// sets a Claude Code autocompact env/window: Claude Code's own compaction math is untouched;
+// only what the GATEWAY reports back changes.
+export const GATEWAY_COMPACTION_UPLOAD_TARGET_KEY = "GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS";
+/** The lowest token count `--compact-at` / `compact_at` / `MNEMOM_COMPACT_AT` will accept. */
+export const COMPACT_AT_MIN_TOKENS = 50_000;
+/**
+ * The parser's ceiling (exclusive): the largest window Claude Code runs. It is NOT where a target
+ * stops working — the gateway ignores a target at or above the compaction point of the window
+ * the session actually runs on (COMPACT_AT_TRIGGER_1M / COMPACT_AT_TRIGGER_200K, below), which
+ * `compactAtWindowWarning` tells the user about at launch.
+ */
+export const COMPACT_AT_MAX_TOKENS = 1_000_000;
+/**
+ * Claude Code's own compaction point on a 1M and on a 200k window — the gateway's
+ * `ALIGN_T_1M` / `ALIGN_T_200K` (gateway/src/compaction-align.ts). The gateway honours an upload
+ * target only BELOW the point of the window the request runs on (`target_over_threshold`
+ * otherwise), and says nothing back to the client when it ignores one.
+ */
+export const COMPACT_AT_TRIGGER_1M = 967_000;
+export const COMPACT_AT_TRIGGER_200K = 167_000;
+/**
+ * `resolveWindowModel`'s answer as a window. `one-m` and a model already suffixed `[1m]` are
+ * 1M; the `CLAUDE_CODE_DISABLE_1M_CONTEXT` opt-out and a model with no 1M window are 200k (the
+ * request then carries no 1M beta, so the gateway uses its 200k point too). A passthrough
+ * `-- --model`, a resume, Claude Code's own default, any other suffix, and a non-Claude-Code CLI
+ * (`null`) are unknown.
+ */
+export function launchWindow(win) {
+    if (win === null)
+        return "unknown";
+    switch (win.reason) {
+        case "one-m":
+            return "1m";
+        case "suffixed":
+            return /\[1m\]\s*$/i.test(win.model ?? "") ? "1m" : "unknown";
+        case "opt-out":
+        case "unsupported":
+            return "200k";
+        default:
+            return "unknown";
+    }
+}
+/**
+ * The launch warning for a target the gateway will (or may) ignore because it is at or above
+ * the compaction point of the window this launch runs on; `null` when the target can take
+ * effect (or there is no target). On an unknown window a target in `[167k, 967k)` works only
+ * if the session lands on a 1M window, so the line says so instead of staying silent.
+ */
+export function compactAtWindowWarning(compactAt, window) {
+    if (compactAt === null)
+        return null;
+    const at = formatTokenCount(compactAt);
+    const t1m = formatTokenCount(COMPACT_AT_TRIGGER_1M);
+    const t200k = formatTokenCount(COMPACT_AT_TRIGGER_200K);
+    if (compactAt >= COMPACT_AT_TRIGGER_1M ||
+        (window === "200k" && compactAt >= COMPACT_AT_TRIGGER_200K)) {
+        const [w, t] = window === "200k" ? ["200k", t200k] : window === "1m" ? ["1M", t1m] : ["any", t1m];
+        return (`mnemom agent: warning: compaction target ${at} is at or above Claude Code's own compaction ` +
+            `point on ${w === "any" ? "any" : `this launch's ${w}`} window (${t}), so the gateway will ignore it. ` +
+            `Pick a value below ${t}.`);
+    }
+    if (window === "unknown" && compactAt >= COMPACT_AT_TRIGGER_200K) {
+        return (`mnemom agent: note: compaction target ${at} takes effect only on a 1M window (below ${t1m}); ` +
+            `if this session runs on a 200k window, the gateway's point is ${t200k} and it ignores the target.`);
+    }
+    return null;
+}
+/**
+ * Parse a `--compact-at` / `compact_at` / `MNEMOM_COMPACT_AT` value. `source` names the
+ * surface in the error so a customer knows which setting to fix (same convention as
+ * `parseContextProfile`).
+ *
+ *   - "" (unset), "1m", "off" (trimmed, case-insensitive) → `null`: no gateway target —
+ *     Claude Code runs its normal 1M window and nothing new is sent.
+ *   - a bare integer, or one with a `k`/`m` suffix (`200k` → 200000, `0.5m` → 500000) →
+ *     that many tokens, when it is in `[COMPACT_AT_MIN_TOKENS, COMPACT_AT_MAX_TOKENS)`.
+ *   - anything else, or a number outside that range (use `1m`/`off` for the ceiling and
+ *     above, never a bare `1000000`) → throws with a human-readable message.
+ */
+export function parseCompactAt(raw, source) {
+    const v = raw.trim().toLowerCase();
+    if (v === "" || v === "1m" || v === "off")
+        return null;
+    const m = /^(\d+(?:\.\d+)?)(k|m)?$/.exec(v);
+    if (!m) {
+        throw new Error(`${source} must be a token count (optionally with a k/m suffix), '1m', or 'off' (got '${raw}').`);
+    }
+    const mult = m[2] === "k" ? 1_000 : m[2] === "m" ? 1_000_000 : 1;
+    const tokens = Math.round(Number(m[1]) * mult);
+    if (!Number.isFinite(tokens) ||
+        tokens < COMPACT_AT_MIN_TOKENS ||
+        tokens >= COMPACT_AT_MAX_TOKENS) {
+        throw new Error(`${source} must be between ${COMPACT_AT_MIN_TOKENS} and ${COMPACT_AT_MAX_TOKENS - 1} tokens` +
+            ` (or '1m' / 'off' for no gateway compaction target); got '${raw}'.`);
+    }
+    return tokens;
+}
+/**
+ * Which compaction target this launch runs under. Precedence, highest wins:
+ *   1. `opts.compactAt` — an already-parsed `--compact-at` flag value (`undefined` when the
+ *      flag was not given at all; `null` is a valid, explicit "no target" from `1m`/`off`).
+ *   2. `MNEMOM_COMPACT_AT` (which `applyConfigToEnv` sets from the `compact_at` launcher.toml
+ *      key, UNDER any real env var — so an operator's own env always wins over the file).
+ *   3. `null` — the default: no target, nothing new sent.
+ */
+export function resolveCompactAt(opts) {
+    if (opts.compactAt !== undefined)
+        return opts.compactAt;
+    const raw = (opts.env?.MNEMOM_COMPACT_AT ?? "").trim();
+    if (raw === "")
+        return null;
+    return parseCompactAt(raw, "MNEMOM_COMPACT_AT");
+}
+/**
+ * `--no-compaction-intercept` is a deliberate, documented "keep the intercept off for this
+ * launch no matter what toml/env says" signal. A compaction target needs that SAME intercept
+ * to arm (`buildSessionConfig` ORs them), so pairing an explicit `--no-compaction-intercept`
+ * with an armed `--compact-at` is a contradiction — refuse rather than silently pick a side
+ * (either silently re-arming the intercept the user just turned off, or silently sending an
+ * inert upload-target the gateway can never act on). `compactionIntercept` here is the raw,
+ * pre-`resolveCompactionIntercept` flag value: `false` only when `--no-compaction-intercept`
+ * was explicitly passed (or the experimental gate forced it, which `compactAt` cannot reach
+ * past either — see index.ts's `assertEnabled`), never the mere absence of `--compaction-intercept`.
+ */
+export function assertCompactAtCompatible(opts) {
+    if (opts.compactionIntercept === false && opts.compactAt !== null) {
+        throw new Error("mnemom agent: --compact-at needs the compaction intercept to arm, but it is off for " +
+            "this launch (--no-compaction-intercept, or the compaction-intercept experimental " +
+            "feature is disabled). Drop --no-compaction-intercept (and run `mnemom experimental " +
+            "enable compaction-intercept`), or pass --compact-at off.");
+    }
+}
+/**
+ * `200000` → `"200k"`, anything not k-aligned → the bare digits. Every real caller only ever
+ * passes a `parseCompactAt`-validated value, which is bounded to
+ * `[COMPACT_AT_MIN_TOKENS, COMPACT_AT_MAX_TOKENS)` — i.e. `[50_000, 999_999]` — so there is no
+ * multiple of 1,000,000 to round to an `"Nm"` form; that case is intentionally not handled here.
+ */
+function formatTokenCount(tokens) {
+    if (tokens % 1_000 === 0)
+        return `${tokens / 1_000}k`;
+    return String(tokens);
+}
+/** The launch-banner line for the resolved compaction target (always printed). */
+export function describeCompactAt(compactAt) {
+    return compactAt === null
+        ? "Claude Code default (1M)"
+        : `gateway at ${formatTokenCount(compactAt)}`;
+}
 /**
  * Claude Code's opt-in for its gateway hint headers (`x-claude-code-request-class: main |
  * compaction`, `x-claude-code-compaction: auto | manual | reactive`,
@@ -768,9 +933,11 @@ export function resolveContextProfile(opts) {
  * `x-mnemom-session-config` payload, in wire order: the profile's keys first
  * (`CONTEXT_RUNTIME_ENABLED` for `off`; the three fold-tuning keys for `aggressive`; nothing
  * for `balanced`), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON, then
- * `GATEWAY_USAGE_REAL_SIZE: "on"` + `GATEWAY_COMPACTION_INTERCEPT: "on"` when the compaction
- * intercept is ON. Empty for `balanced` with both off — the common case, where no header is sent at all.
- * Exported so `--dry-run` can list exactly what the header carries.
+ * `GATEWAY_USAGE_REAL_SIZE: "on"` + `GATEWAY_COMPACTION_INTERCEPT: "on"` when EITHER the
+ * `compaction_intercept` setting is ON OR `--compact-at` arms a target below 1M (the target
+ * cannot be honored without the intercept), then `GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS: "<N>"`
+ * when a target is set. Empty for `balanced` with everything off — the common case, where no
+ * header is sent at all. Exported so `--dry-run` can list exactly what the header carries.
  */
 export function buildSessionConfig(opts) {
     const config = {};
@@ -778,10 +945,17 @@ export function buildSessionConfig(opts) {
         config[k] = v;
     if (opts.contextHandoff)
         config[CONTEXT_HANDOFF_KEY] = "true";
-    if (opts.compactionIntercept) {
+    const hasCompactionTarget = opts.compactAt !== undefined && opts.compactAt !== null;
+    // A target needs the compaction intercept + real-size rewrite to arm (#2216) — without them
+    // the upload-target key is silently inert (compaction-align.ts: "armed only inside the
+    // intercept"). Deliberately NOT GATEWAY_COMPACTION_REFOLD — a separate, costlier opt-in.
+    if (opts.compactionIntercept || hasCompactionTarget) {
         config[USAGE_REAL_SIZE_KEY] = "on";
         config[COMPACTION_INTERCEPT_KEY] = "on";
     }
+    if (hasCompactionTarget) {
+        config[GATEWAY_COMPACTION_UPLOAD_TARGET_KEY] = String(opts.compactAt);
+    }
     return config;
 }
 /**
@@ -800,12 +974,15 @@ export function buildSessionConfigPayload(opts) {
 }
 /**
  * The `x-mnemom-session-config` value for this launch, or `undefined` when there is
- * nothing to override (the gateway's own defaults stand — `balanced` with handoff off,
- * byte-identical to a launch before profiles existed). Two independent overlays:
+ * nothing to override (the gateway's own defaults stand — `balanced` with everything else off,
+ * byte-identical to a launch before profiles existed). Independent overlays:
  *   - the context profile (`buildSessionConfig`): `off` → `CONTEXT_RUNTIME_ENABLED: "false"`,
  *     `aggressive` → the three fold-tuning keys, `balanced` → nothing;
  *   - `compactionIntercept: true` → `GATEWAY_USAGE_REAL_SIZE` + `GATEWAY_COMPACTION_INTERCEPT`
  *     `"on"` (the `compaction_intercept` setting);
+ *   - `compactAt: <N>` (`--compact-at`, below 1M) → the SAME two intercept keys plus
+ *     `GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS: "<N>"`; unset, `1m` or `off` → nothing beyond
+ *     what `compactionIntercept` already sent (Claude Code's own 1M window, untouched);
  *   - `contextHandoff: true` → `CONTEXT_HANDOFF_ENABLED: "true"` (the `context_handoff`
  *     setting) — the SAME header the `handoff` MCP tool's own call to
  *     `/mnemom/context/handoff` must also send, since the gateway resolves the flag

package/dist/lib/experimental.d.ts

@@ -13,6 +13,15 @@
  * modules are the thin drivers.
  */
 export type ExperimentalId = "context-handoff" | "slack" | "implicit" | "compaction-intercept";
+/**
+ * Is a `compact_at` / `MNEMOM_COMPACT_AT` value (trimmed, case-insensitive) an ARMED gateway
+ * target, as opposed to "no target" (`""`, `"1m"`, `"off"`)? Deliberately duplicates
+ * `parseCompactAt`'s no-target spellings rather than importing it, to keep this registry
+ * dependency-free (see the module doc); an unparseable value (bad k/m suffix, out of range)
+ * is treated as armed so the gate errs toward requiring the opt-in rather than toward silently
+ * admitting a value the real parser would reject anyway.
+ */
+export declare function compactAtArmed(raw: string | undefined): boolean;
 export interface ExperimentalFeature {
     id: ExperimentalId;
     summary: string;
@@ -73,8 +82,8 @@ export declare function assertEnabled(uses: ReadonlyArray<{
 export declare function experimentalIdForConfigKey(key: string, value: string): ExperimentalId | undefined;
 /**
  * The stderr lines for experimental settings a launch ignores because their feature
- * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF and
- * MNEMOM_AGENT_COMPACTION_INTERCEPT.
+ * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF,
+ * MNEMOM_AGENT_COMPACTION_INTERCEPT and MNEMOM_COMPACT_AT (an armed target only).
  */
 export declare function ignoredSettingLines(opts: {
     entries: ReadonlyArray<[string, string]>;

package/dist/lib/experimental.js

@@ -12,6 +12,18 @@
  * Everything here is pure or dependency-injected; index.ts and the command
  * modules are the thin drivers.
  */
+/**
+ * Is a `compact_at` / `MNEMOM_COMPACT_AT` value (trimmed, case-insensitive) an ARMED gateway
+ * target, as opposed to "no target" (`""`, `"1m"`, `"off"`)? Deliberately duplicates
+ * `parseCompactAt`'s no-target spellings rather than importing it, to keep this registry
+ * dependency-free (see the module doc); an unparseable value (bad k/m suffix, out of range)
+ * is treated as armed so the gate errs toward requiring the opt-in rather than toward silently
+ * admitting a value the real parser would reject anyway.
+ */
+export function compactAtArmed(raw) {
+    const v = (raw ?? "").trim().toLowerCase();
+    return v !== "" && v !== "1m" && v !== "off";
+}
 export const EXPERIMENTAL_FEATURES = [
     {
         id: "context-handoff",
@@ -140,6 +152,9 @@ export function experimentalIdForConfigKey(key, value) {
             return value === "true" ? "context-handoff" : undefined;
         case "compaction_intercept":
             return value === "true" ? "compaction-intercept" : undefined;
+        case "compact_at":
+            // Arms the SAME gateway keys compaction_intercept does — same gate.
+            return compactAtArmed(value) ? "compaction-intercept" : undefined;
         case "goal_mode":
             return value === "implicit" ? "implicit" : undefined;
         default:
@@ -152,8 +167,8 @@ function truthy(raw) {
 }
 /**
  * The stderr lines for experimental settings a launch ignores because their feature
- * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF and
- * MNEMOM_AGENT_COMPACTION_INTERCEPT.
+ * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF,
+ * MNEMOM_AGENT_COMPACTION_INTERCEPT and MNEMOM_COMPACT_AT (an armed target only).
  */
 export function ignoredSettingLines(opts) {
     const lines = [];
@@ -170,6 +185,10 @@ export function ignoredSettingLines(opts) {
         !opts.enabled.includes("compaction-intercept")) {
         lines.push(`mnemom agent: ignoring ${gatedMessage("MNEMOM_AGENT_COMPACTION_INTERCEPT", "compaction-intercept")}`);
     }
+    if (compactAtArmed(opts.env.MNEMOM_COMPACT_AT) &&
+        !opts.enabled.includes("compaction-intercept")) {
+        lines.push(`mnemom agent: ignoring ${gatedMessage("MNEMOM_COMPACT_AT", "compaction-intercept")}`);
+    }
     return lines;
 }
 /** The features an existing launcher.toml already uses (the one-time migration). */

package/dist/lib/first-run/backtest.d.ts

@@ -6,17 +6,14 @@
  * Read-only; no network. Only token counts, model ids and timestamps are read from a
  * transcript line — never message content.
  *
- * The curve (lower 95% bootstrap bound of the size-matched per-request saving, rounded
- * DOWN to 0.1 pt) comes from the S43 / S44 chain45 and d240p1 marathon paired arms:
- * mnemom-adw scratchpad/wow-first-run/CURVE-REPORT.md, curve/curve.json. The strategy is
- * chosen PER REQUEST from that request's original context (operator policy 2026-09-30):
- *
- *   < 200k        none (no fold)  → 0 on screen (the measured balanced rate there is
- *                                   slightly negative; floored, raw kept for the audit)
- *   200k – 700k   aggressive      → the measured lower bound of its bin
- *   700k – 1M     aggressive      → the 400–700k bound, EXTRAPOLATED (no measured pair)
- *   ≥ 1M          balanced        → 0 (live sessions only; a stock history cannot get
- *                                   there because Claude Code compacts first — counted)
+ * The rate is ONE flat number (operator policy 2026-10-02): the median paired total-bill
+ * saving of the S46 chain45 C2n arm (context runtime, aggressive profile, no goal) against
+ * stock, 23.8% over n = 13 counted rounds (mnemom-adw scratchpad/trustcode-mvp/runs/
+ * s46-status.json; early exits and void arms excluded). It applies to every request whose
+ * original context is at or above the aggressive profile's fold point (its 60k tail
+ * budget); smaller requests never fold, so they save 0. A flat rate over-counts mid-size
+ * contexts and under-counts large ones; in aggregate that evens out. Per-size rates come
+ * back once there are enough measured pairs.
  */
 /** One billed request, deduped by message id. `t` is epoch seconds. */
 export interface Row {
@@ -59,28 +56,14 @@ export declare function parseUsageLine(line: Buffer, subagent: boolean): {
  * session copies messages) is skipped, so each request is billed once, to its origin.
  */
 export declare function loadTranscript(path: string, seen?: Set<string>): Row[];
-/** Original-context bin edges (tokens). */
-export declare const CURVE_EDGES: readonly [0, 100000, 200000, 300000, 400000, 700000, 1000000];
-/**
- * Lower 95% bound per bin, rounded down to 0.1 pt (curve/curve.json `strategies`).
- * aggressive: no measured pair below 100k or at/above 700k.
- */
-export declare const CURVE_LOWER: Readonly<Record<"aggressive" | "balanced", Record<number, number>>>;
-export declare const NO_FOLD_BELOW = 200000;
-export declare const EXTRAPOLATE_FROM = 700000;
-export declare const BALANCED_FROM = 1000000;
-export declare const POLICY = "none <200k / aggressive 200k-1M / balanced 1M+ (1M+ applies only to live sessions)";
+/** S46 C2n vs stock, median paired total-bill saving (n = 13). */
+export declare const S46_MEDIAN_SAVING = 0.238;
+/** The aggressive profile's tail budget (cli/src/lib/agent.ts): below it nothing folds. */
+export declare const AGGRESSIVE_FOLD_FROM = 60000;
 export declare const ESTIMATOR_METHOD: string;
-export type Strategy = "none" | "aggressive" | "balanced_1M+";
-export type RateNote = "floored_at_0" | "extrapolated" | "exception_1M_plus" | null;
-/** The curve bin of an original context (0 = below 100k; the top bin is open-ended). */
-export declare function binOf(x: number): number;
-/** The screen never claims a negative saving: a negative measured rate shows as 0. */
-export declare function floorRate(raw: number): {
-    screen: number;
-    note: "floored_at_0" | null;
-};
-/** The per-request rate the screen uses (`screen`) and the honest measured one (`raw`). */
+export type Strategy = "none" | "aggressive";
+export type RateNote = "below_aggressive" | null;
+/** The per-request rate the screen uses. `raw` equals `screen`: no floor, no curve. */
 export declare function ruleRate(x: number): {
     strategy: Strategy;
     raw: number;
@@ -90,7 +73,7 @@ export declare function ruleRate(x: number): {
 export interface Estimate {
     actual: number;
     saved: number;
-    /** The saving with the < 200k band NOT floored (audit only; never shown). */
+    /** Same as `saved` now that no rate is floored (kept for the audit record). */
     rawSaved: number;
     peak: number;
     requests: number;

package/dist/lib/first-run/backtest.js

@@ -6,17 +6,14 @@
  * Read-only; no network. Only token counts, model ids and timestamps are read from a
  * transcript line — never message content.
  *
- * The curve (lower 95% bootstrap bound of the size-matched per-request saving, rounded
- * DOWN to 0.1 pt) comes from the S43 / S44 chain45 and d240p1 marathon paired arms:
- * mnemom-adw scratchpad/wow-first-run/CURVE-REPORT.md, curve/curve.json. The strategy is
- * chosen PER REQUEST from that request's original context (operator policy 2026-09-30):
- *
- *   < 200k        none (no fold)  → 0 on screen (the measured balanced rate there is
- *                                   slightly negative; floored, raw kept for the audit)
- *   200k – 700k   aggressive      → the measured lower bound of its bin
- *   700k – 1M     aggressive      → the 400–700k bound, EXTRAPOLATED (no measured pair)
- *   ≥ 1M          balanced        → 0 (live sessions only; a stock history cannot get
- *                                   there because Claude Code compacts first — counted)
+ * The rate is ONE flat number (operator policy 2026-10-02): the median paired total-bill
+ * saving of the S46 chain45 C2n arm (context runtime, aggressive profile, no goal) against
+ * stock, 23.8% over n = 13 counted rounds (mnemom-adw scratchpad/trustcode-mvp/runs/
+ * s46-status.json; early exits and void arms excluded). It applies to every request whose
+ * original context is at or above the aggressive profile's fold point (its 60k tail
+ * budget); smaller requests never fold, so they save 0. A flat rate over-counts mid-size
+ * contexts and under-counts large ones; in aggregate that evens out. Per-size rates come
+ * back once there are enough measured pairs.
  */
 import { forEachLine, isoSeconds, parseJson } from "./lines.js";
 /**
@@ -137,51 +134,19 @@ export function loadTranscript(path, seen) {
     }
     return out;
 }
-// ── the empirical curve ──────────────────────────────────────────────────────
-/** Original-context bin edges (tokens). */
-export const CURVE_EDGES = [0, 100_000, 200_000, 300_000, 400_000, 700_000, 1_000_000];
-/**
- * Lower 95% bound per bin, rounded down to 0.1 pt (curve/curve.json `strategies`).
- * aggressive: no measured pair below 100k or at/above 700k.
- */
-export const CURVE_LOWER = {
-    // bin 1 (100-200k) is measured at -0.059 but never used: < 200k runs no fold.
-    aggressive: { 2: 0.137, 3: 0.282, 4: 0.342 },
-    balanced: { 0: -0.222, 1: -0.028, 2: 0.055, 3: 0.081, 4: 0.163, 5: 0.43 },
-};
-export const NO_FOLD_BELOW = 200_000;
-export const EXTRAPOLATE_FROM = 700_000;
-export const BALANCED_FROM = 1_000_000;
-export const POLICY = "none <200k / aggressive 200k-1M / balanced 1M+ (1M+ applies only to live sessions)";
-export const ESTIMATOR_METHOD = "empirical curve (lower 95% bound, rounded down), strategy per request by its original context, " +
-    `policy ${POLICY}: < 200k the balanced arm's measured rate floored at 0, 200k-1M aggressive by bin ` +
-    "(>= 700k: the 400-700k rate, extrapolated); request count and output held at stock";
-/** The curve bin of an original context (0 = below 100k; the top bin is open-ended). */
-export function binOf(x) {
-    let i = 0;
-    while (i < CURVE_EDGES.length - 2 && x >= CURVE_EDGES[i + 1])
-        i++;
-    return i;
-}
-/** The screen never claims a negative saving: a negative measured rate shows as 0. */
-export function floorRate(raw) {
-    return raw < 0 ? { screen: 0, note: "floored_at_0" } : { screen: raw, note: null };
-}
-/** The per-request rate the screen uses (`screen`) and the honest measured one (`raw`). */
+// ── the saving rate ──────────────────────────────────────────────────────────
+/** S46 C2n vs stock, median paired total-bill saving (n = 13). */
+export const S46_MEDIAN_SAVING = 0.238;
+/** The aggressive profile's tail budget (cli/src/lib/agent.ts): below it nothing folds. */
+export const AGGRESSIVE_FOLD_FROM = 60_000;
+export const ESTIMATOR_METHOD = "flat S46 median (23.8%, C2n vs stock, n = 13) on every request whose original context is " +
+    ">= 60k (the aggressive profile's fold point), 0 below; request count and output held at stock";
+/** The per-request rate the screen uses. `raw` equals `screen`: no floor, no curve. */
 export function ruleRate(x) {
-    if (x >= BALANCED_FROM) {
-        return { strategy: "balanced_1M+", raw: 0, screen: 0, note: "exception_1M_plus" };
-    }
-    if (x < NO_FOLD_BELOW) {
-        const raw = CURVE_LOWER.balanced[binOf(x)];
-        return { strategy: "none", raw, ...floorRate(raw) };
-    }
-    if (x >= EXTRAPOLATE_FROM) {
-        const r = CURVE_LOWER.aggressive[binOf(400_000)];
-        return { strategy: "aggressive", raw: r, screen: r, note: "extrapolated" };
+    if (x < AGGRESSIVE_FOLD_FROM) {
+        return { strategy: "none", raw: 0, screen: 0, note: "below_aggressive" };
     }
-    const r = CURVE_LOWER.aggressive[binOf(x)];
-    return { strategy: "aggressive", raw: r, screen: r, note: null };
+    return { strategy: "aggressive", raw: S46_MEDIAN_SAVING, screen: S46_MEDIAN_SAVING, note: null };
 }
 /** The one swap point: rows → list-price actual and the conservative saving. */
 export function estimate(rows) {

package/dist/lib/first-run/index.js

@@ -209,7 +209,7 @@ export const LEDGER_SIGNALS = new Set(["registry_cc_id", "registry_conv_id"]);
 /** The screen's hard budget: a regression in buildScreen's line dropping must fail loudly. */
 export function assertScreenBudget(lines) {
     if (lines.length > MAX_LINES || lines.some((l) => l.length > WIDTH)) {
-        throw new Error("first-run screen exceeded its 16 x 78 budget");
+        throw new Error(`first-run screen exceeded its ${MAX_LINES} x ${WIDTH} budget`);
     }
 }
 /** A transcript's mtime (ms), 0 when it vanished since discovery (it then sorts first). */

package/dist/lib/first-run/screen.d.ts

@@ -1,5 +1,5 @@
 /**
- * The first-run screen: one plain terminal screen (at most 16 lines of at most 78
+ * The first-run screen: one plain terminal screen (at most 22 lines of at most 78
  * columns, ASCII) built from the backtest numbers. Pure — no I/O — so every layout is
  * unit-tested. Every number on it is recorded in the audit with its raw value and
  * method.
@@ -25,7 +25,7 @@
  *   - No live counter is promised: `mnemom agent` has no status bar today.
  */
 export declare const WIDTH = 78;
-export declare const MAX_LINES = 16;
+export declare const MAX_LINES = 22;
 /** Less history than this (API prices, in the window) is too little to backtest. */
 export declare const MIN_HISTORY_USD = 5;
 /** Variation A iff the shown saving is at least this many dollars and this many percent. */
@@ -33,12 +33,12 @@ export declare const STRONG_MIN_USD = 5;
 export declare const STRONG_MIN_PCT = 5;
 export declare const DAYS = 30;
 /**
- * The forward line: the best finished chain45 run with its error margin (operator
- * 2026-10-01, until something better): S43 C2 total bill -19.5% [-23.9, -14.9], Opus 5.5,
- * n=23, 95% CI rounded to 15-25. The d240p1 ~45% figure is NOT used (its re-bill
- * undercounts output).
+ * The forward line: chain45 S46 C2n (context runtime, aggressive profile) total bill vs
+ * stock, -20.9% [-25.6, -15.9], Opus 5.5, n=13 (r15 readout; operator 2026-10-02: quote
+ * S46, not S43), 95% CI rounded to fives, 15-25. The d240p1 ~45% figure is NOT used
+ * (its re-bill undercounts output).
  */
-export declare const FORWARD_LINE = "Long sessions are where Mnemom saves the most: about 15 to 25% in our tests.";
+export declare const FORWARD_LINE = "Long sessions are where Mnemom saves the most: about 15 to 25% in our datasets.";
 /** Prices, promotions and plan allocations move; the saving is in usage (operator 2026-10-01). */
 export declare const PRICE_LINE = "Prices and plan limits change. Mnemom cuts what you use, so you stay ahead.";
 /** What `mnemom agent` does today: routes through the gateway, records, keeps context lean. */
@@ -52,8 +52,8 @@ export declare function sig3(x: number): number;
  * screen. The implied saving is the shown saving, which never exceeds the raw saving.
  */
 export declare function pair(total: number, saved: number): [number, number, number];
-/** part / whole as a percentage rounded DOWN to a multiple of 5. */
-export declare function pct5(part: number, whole: number): number;
+/** part / whole as a whole-number percentage, decimals dropped (rounded DOWN). */
+export declare function pctDown(part: number, whole: number): number;
 export declare function day(t: number): string;
 export declare function usd(n: number): string;
 export declare function clean(s: string): string;