@mnemom/mnemom 0.17.4-next.3 → 0.17.4-next.4

package/dist/lib/agent.d.ts

@@ -116,6 +116,118 @@ export declare function sanitizeAgentName(raw: string): string;
  * post`) can identify themselves by the same name the claude.ai session list shows.
  */
 export declare const SESSION_NAME_ENV = "MNEMOM_AGENT_SESSION_NAME";
+/**
+ * Claude Code's tool-search switch. Behind an ANTHROPIC_BASE_URL that is not an Anthropic host
+ * (the gateway door), Claude Code turns tool search OFF unless this is set, and then inlines
+ * every tool schema — MCP included — on every request (EIM: 311 tools, a ~245k-token fixed
+ * prefix, a 200k session that starts at "0% left" and compaction that can never get under it).
+ * Claude Code 2.1.282 / 2.1.285 log `[ToolSearch:optimistic] disabled: ANTHROPIC_BASE_URL=… is
+ * not a first-party Anthropic host. Set ENABLE_TOOL_SEARCH=true (or auto / auto:N) if your proxy
+ * forwards tool_reference blocks.` and parse: `force`, `auto`, `auto:N` (0–100), a truthy value
+ * (1/true/yes/on) ⇒ tool search on, a falsy one (0/false/no/off) ⇒ off; empty/unset ⇒ off behind
+ * a proxy.
+ */
+export declare const TOOL_SEARCH_ENV = "ENABLE_TOOL_SEARCH";
+/**
+ * Turn Claude Code's tool search on for a gateway launch: sets ENABLE_TOOL_SEARCH=true in the
+ * child env unless the user already gave it a value (any non-blank value — `false`, `auto:50`,
+ * `force` — is theirs and is kept). A blank value counts as unset: Claude Code reads it as unset
+ * too. Mutates and returns `env`.
+ */
+export declare function applyToolSearchDefault(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** The value of a passthrough `--model <id>` / `--model=<id>`, else null. */
+export declare function passthroughModel(passthrough: readonly string[]): string | null;
+/** Where a launch's model came from (resolveLaunchModel). */
+export type LaunchModelSource = "flag" | "passthrough" | "env" | "none";
+export interface LaunchModel {
+    /** The model this launch runs on as far as the launcher can tell (the ledger records it). */
+    model: string | null;
+    source: LaunchModelSource;
+}
+/**
+ * The model a launch runs on, kept VERBATIM — a `[1m]` suffix included, which is what makes
+ * Claude Code send the `context-1m-2025-08-07` beta and size its window at 1M (verified against
+ * real claude 2.1.285 behind a local base URL, for `--model` and for ANTHROPIC_MODEL):
+ *   1. `--model` (or launcher.toml `model`) → what buildCliArgs injects / the server shape's
+ *      ANTHROPIC_MODEL;
+ *   2. a passthrough `-- --model <id>` → already on the CLI's argv;
+ *   3. ANTHROPIC_MODEL in the environment → every launch shape's child inherits it;
+ *   4. nothing → Claude Code's own default (on `--resume` Claude Code restores the session's
+ *      own model, `[1m]` included), recorded as null.
+ * Only `--model` is ever injected; the rest is what the ledger records so `mnemom agent
+ * sessions` shows the window a session ran with instead of null.
+ */
+export declare function resolveLaunchModel(input: {
+    explicit?: string;
+    passthrough: readonly string[];
+    env: Record<string, string | undefined>;
+}): LaunchModel;
+/**
+ * Claude Code's own 1M opt-out. Its window code short-circuits on it (`function xD(){return
+ * a.CLAUDE_CODE_DISABLE_1M_CONTEXT}`; every `[1m]` path checks `if(xD())return!1` first, and a
+ * `[1m]` model switch under it fails with "1M context is turned off (CLAUDE_CODE_DISABLE_1M_CONTEXT
+ * is set)"). Set in the environment or in a settings `env` block, it is the user's explicit
+ * 200k choice and the launcher then adds no `[1m]`.
+ */
+export declare const DISABLE_1M_ENV = "CLAUDE_CODE_DISABLE_1M_CONTEXT";
+/** The window suffix Claude Code reads off a model id (`/\[1m\]/i` → 1M + `context-1m` beta). */
+export declare const ONE_M_SUFFIX = "[1m]";
+/**
+ * Whether `[1m]` may be appended to `model`. Claude Code does NOT check this itself: given
+ * `--model haiku[1m]` or `default[1m]` it sends the 1M beta (and, for `default`, a model id of
+ * `default`) upstream (measured, claude 2.1.282 / 2.1.285). So the launcher allows only the
+ * `opus` / `sonnet` aliases and concrete `claude-opus-*` / `claude-sonnet-*` ids, minus the ids
+ * Claude Code itself lists as having no 1M window (`function mde(e){return
+ * e.includes("claude-3-")||e==="claude-opus-4-0"||e==="claude-opus-4-1"||e==="claude-opus-4-5"||
+ * e==="claude-haiku-4-5"}`) — `claude-opus-4` / `-4-0` / `-4-1` / `-4-5`, dated or not. Anything
+ * else (haiku, non-Claude router models, unknown families) is left as given.
+ */
+export declare function supportsOneM(model: string): boolean;
+/** The parts of Claude Code's settings files the window default reads. */
+export interface CcSettingsView {
+    model?: string;
+    env?: Record<string, string | undefined>;
+}
+/**
+ * Claude Code's settings files, highest precedence first: `<cwd>/.claude/settings.local.json`,
+ * `<cwd>/.claude/settings.json`, then the user's `settings.json` under CLAUDE_CONFIG_DIR (else
+ * `~/.claude`). Unreadable or malformed files are skipped. Managed (MDM) settings are not read.
+ */
+export declare function readCcSettings(opts: {
+    cwd: string;
+    configDir: string;
+    readFile?: (path: string) => string;
+}): CcSettingsView[];
+/** Why the launch model came out the way it did (resolveWindowModel). */
+export type WindowReason = "one-m" | "opt-out" | "passthrough" | "suffixed" | "unsupported" | "resume" | "cc-default";
+export interface WindowModel {
+    /** The model to launch with (`--model`, or the server shape's ANTHROPIC_MODEL); undefined = none. */
+    model: string | undefined;
+    reason: WindowReason;
+    /** The model before `[1m]` was appended (reason "one-m" only). */
+    from?: string;
+}
+/**
+ * The launch model with the 1M window as the default. The model the launch would run on — the
+ * `--model` flag (or launcher.toml `model`), else an inherited ANTHROPIC_MODEL, else Claude Code's
+ * settings (`env.ANTHROPIC_MODEL`, then `model`) — gets `[1m]` appended when it has no window
+ * suffix and supports 1M. Claude Code reads the window off the id: `[1m]` ⇒ a 1M window and the
+ * `context-1m-2025-08-07` beta (`function ift(e){return/\[1m\]/i.test(e)}`; `Ob()` returns 1e6
+ * when it matches). Without it, claude 2.1.282 runs a bare `opus` / `claude-opus-4-8` at 200k on
+ * both auth paths (the EIM thrash window); 2.1.285 already gives those ids 1M, where `[1m]` is
+ * harmless.
+ *
+ * Never overrides an explicit choice: CLAUDE_CODE_DISABLE_1M_CONTEXT (env or settings env), a
+ * passthrough `-- --model`, and any model that already names a window are left exactly as
+ * given. A resume with no model injects nothing (Claude Code restores the session's model,
+ * `[1m]` included), and so does a launch with no model anywhere (Claude Code's default).
+ */
+export declare function resolveWindowModel(input: {
+    explicit?: string;
+    passthrough: readonly string[];
+    env: Record<string, string | undefined>;
+    settings: () => CcSettingsView[];
+}): WindowModel;
 /**
  * Claude Code's opt-in for its gateway hint headers (`x-claude-code-request-class`,
  * `x-claude-code-agent-type`, `x-claude-code-prompt-id`). CC sends them to api.anthropic.com on

package/dist/lib/agent.js

@@ -20,6 +20,8 @@
  * NAMED), but prod is never selected silently — see `resolveGatewayHost`.
  */
 import { createHash, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { getGatewayUrl } from "./config.js";
 /** The us-2/prod gateway host. The default door — never any other cell silently. */
 export const PROD_GATEWAY_HOST = "https://gateway.mnemom.ai";
@@ -117,6 +119,188 @@ export function sanitizeAgentName(raw) {
  * post`) can identify themselves by the same name the claude.ai session list shows.
  */
 export const SESSION_NAME_ENV = "MNEMOM_AGENT_SESSION_NAME";
+/**
+ * Claude Code's tool-search switch. Behind an ANTHROPIC_BASE_URL that is not an Anthropic host
+ * (the gateway door), Claude Code turns tool search OFF unless this is set, and then inlines
+ * every tool schema — MCP included — on every request (EIM: 311 tools, a ~245k-token fixed
+ * prefix, a 200k session that starts at "0% left" and compaction that can never get under it).
+ * Claude Code 2.1.282 / 2.1.285 log `[ToolSearch:optimistic] disabled: ANTHROPIC_BASE_URL=… is
+ * not a first-party Anthropic host. Set ENABLE_TOOL_SEARCH=true (or auto / auto:N) if your proxy
+ * forwards tool_reference blocks.` and parse: `force`, `auto`, `auto:N` (0–100), a truthy value
+ * (1/true/yes/on) ⇒ tool search on, a falsy one (0/false/no/off) ⇒ off; empty/unset ⇒ off behind
+ * a proxy.
+ */
+export const TOOL_SEARCH_ENV = "ENABLE_TOOL_SEARCH";
+/**
+ * Turn Claude Code's tool search on for a gateway launch: sets ENABLE_TOOL_SEARCH=true in the
+ * child env unless the user already gave it a value (any non-blank value — `false`, `auto:50`,
+ * `force` — is theirs and is kept). A blank value counts as unset: Claude Code reads it as unset
+ * too. Mutates and returns `env`.
+ */
+export function applyToolSearchDefault(env) {
+    if ((env[TOOL_SEARCH_ENV] ?? "").trim() === "")
+        env[TOOL_SEARCH_ENV] = "true";
+    return env;
+}
+/** The value of a passthrough `--model <id>` / `--model=<id>`, else null. */
+export function passthroughModel(passthrough) {
+    for (let i = 0; i < passthrough.length; i++) {
+        const a = passthrough[i];
+        if (a === "--model") {
+            const next = (passthrough[i + 1] ?? "").trim();
+            return next && !next.startsWith("-") ? next : null;
+        }
+        if (a.startsWith("--model="))
+            return a.slice("--model=".length).trim() || null;
+    }
+    return null;
+}
+/**
+ * The model a launch runs on, kept VERBATIM — a `[1m]` suffix included, which is what makes
+ * Claude Code send the `context-1m-2025-08-07` beta and size its window at 1M (verified against
+ * real claude 2.1.285 behind a local base URL, for `--model` and for ANTHROPIC_MODEL):
+ *   1. `--model` (or launcher.toml `model`) → what buildCliArgs injects / the server shape's
+ *      ANTHROPIC_MODEL;
+ *   2. a passthrough `-- --model <id>` → already on the CLI's argv;
+ *   3. ANTHROPIC_MODEL in the environment → every launch shape's child inherits it;
+ *   4. nothing → Claude Code's own default (on `--resume` Claude Code restores the session's
+ *      own model, `[1m]` included), recorded as null.
+ * Only `--model` is ever injected; the rest is what the ledger records so `mnemom agent
+ * sessions` shows the window a session ran with instead of null.
+ */
+export function resolveLaunchModel(input) {
+    const explicit = (input.explicit ?? "").trim();
+    if (explicit)
+        return { model: explicit, source: "flag" };
+    const fromArgv = passthroughModel(input.passthrough);
+    if (fromArgv)
+        return { model: fromArgv, source: "passthrough" };
+    const fromEnv = (input.env.ANTHROPIC_MODEL ?? "").trim();
+    if (fromEnv)
+        return { model: fromEnv, source: "env" };
+    return { model: null, source: "none" };
+}
+/**
+ * Claude Code's own 1M opt-out. Its window code short-circuits on it (`function xD(){return
+ * a.CLAUDE_CODE_DISABLE_1M_CONTEXT}`; every `[1m]` path checks `if(xD())return!1` first, and a
+ * `[1m]` model switch under it fails with "1M context is turned off (CLAUDE_CODE_DISABLE_1M_CONTEXT
+ * is set)"). Set in the environment or in a settings `env` block, it is the user's explicit
+ * 200k choice and the launcher then adds no `[1m]`.
+ */
+export const DISABLE_1M_ENV = "CLAUDE_CODE_DISABLE_1M_CONTEXT";
+/** The window suffix Claude Code reads off a model id (`/\[1m\]/i` → 1M + `context-1m` beta). */
+export const ONE_M_SUFFIX = "[1m]";
+const FALSY = new Set(["0", "false", "no", "off"]);
+/** True when an env-style value turns a switch on: non-blank and not 0/false/no/off. */
+function envOn(v) {
+    const t = (v ?? "").trim().toLowerCase();
+    return t !== "" && !FALSY.has(t);
+}
+/**
+ * Whether `[1m]` may be appended to `model`. Claude Code does NOT check this itself: given
+ * `--model haiku[1m]` or `default[1m]` it sends the 1M beta (and, for `default`, a model id of
+ * `default`) upstream (measured, claude 2.1.282 / 2.1.285). So the launcher allows only the
+ * `opus` / `sonnet` aliases and concrete `claude-opus-*` / `claude-sonnet-*` ids, minus the ids
+ * Claude Code itself lists as having no 1M window (`function mde(e){return
+ * e.includes("claude-3-")||e==="claude-opus-4-0"||e==="claude-opus-4-1"||e==="claude-opus-4-5"||
+ * e==="claude-haiku-4-5"}`) — `claude-opus-4` / `-4-0` / `-4-1` / `-4-5`, dated or not. Anything
+ * else (haiku, non-Claude router models, unknown families) is left as given.
+ */
+export function supportsOneM(model) {
+    const id = model.trim().toLowerCase();
+    if (id === "opus" || id === "sonnet")
+        return true;
+    if (!/^claude-(opus|sonnet)-/.test(id))
+        return false;
+    return !/^claude-opus-4(-[015])?(-\d{8})?$/.test(id);
+}
+/** True when `model` already names a window (`[1m]`, `[2m]`, any `[…]` suffix): left as given. */
+function hasWindowSuffix(model) {
+    return /\[[^\]]*\]\s*$/.test(model);
+}
+/** Passthrough `--resume` / `-r` / `--continue` / `-c`: Claude Code restores the session's model. */
+function resumesSession(passthrough) {
+    return passthrough.some((a) => a === "--resume" ||
+        a === "-r" ||
+        a === "--continue" ||
+        a === "-c" ||
+        a.startsWith("--resume="));
+}
+/**
+ * Claude Code's settings files, highest precedence first: `<cwd>/.claude/settings.local.json`,
+ * `<cwd>/.claude/settings.json`, then the user's `settings.json` under CLAUDE_CONFIG_DIR (else
+ * `~/.claude`). Unreadable or malformed files are skipped. Managed (MDM) settings are not read.
+ */
+export function readCcSettings(opts) {
+    const read = opts.readFile ?? ((p) => readFileSync(p, "utf8"));
+    const out = [];
+    for (const p of [
+        join(opts.cwd, ".claude", "settings.local.json"),
+        join(opts.cwd, ".claude", "settings.json"),
+        join(opts.configDir, "settings.json"),
+    ]) {
+        try {
+            const raw = JSON.parse(read(p));
+            if (!raw || typeof raw !== "object")
+                continue;
+            const o = raw;
+            const view = {};
+            if (typeof o.model === "string")
+                view.model = o.model;
+            if (o.env && typeof o.env === "object") {
+                view.env = Object.fromEntries(Object.entries(o.env).filter((e) => typeof e[1] === "string"));
+            }
+            out.push(view);
+        }
+        catch {
+            // absent / unreadable / not JSON: Claude Code ignores it too
+        }
+    }
+    return out;
+}
+/**
+ * The launch model with the 1M window as the default. The model the launch would run on — the
+ * `--model` flag (or launcher.toml `model`), else an inherited ANTHROPIC_MODEL, else Claude Code's
+ * settings (`env.ANTHROPIC_MODEL`, then `model`) — gets `[1m]` appended when it has no window
+ * suffix and supports 1M. Claude Code reads the window off the id: `[1m]` ⇒ a 1M window and the
+ * `context-1m-2025-08-07` beta (`function ift(e){return/\[1m\]/i.test(e)}`; `Ob()` returns 1e6
+ * when it matches). Without it, claude 2.1.282 runs a bare `opus` / `claude-opus-4-8` at 200k on
+ * both auth paths (the EIM thrash window); 2.1.285 already gives those ids 1M, where `[1m]` is
+ * harmless.
+ *
+ * Never overrides an explicit choice: CLAUDE_CODE_DISABLE_1M_CONTEXT (env or settings env), a
+ * passthrough `-- --model`, and any model that already names a window are left exactly as
+ * given. A resume with no model injects nothing (Claude Code restores the session's model,
+ * `[1m]` included), and so does a launch with no model anywhere (Claude Code's default).
+ */
+export function resolveWindowModel(input) {
+    const explicit = (input.explicit ?? "").trim() || undefined;
+    const given = (reason) => ({ model: explicit, reason });
+    if (passthroughModel(input.passthrough) !== null)
+        return given("passthrough");
+    let settings;
+    const loadSettings = () => (settings ??= input.settings());
+    if (envOn(input.env[DISABLE_1M_ENV]) ||
+        loadSettings().some((s) => envOn(s.env?.[DISABLE_1M_ENV]))) {
+        return given("opt-out");
+    }
+    let base = explicit ?? ((input.env.ANTHROPIC_MODEL ?? "").trim() || undefined);
+    if (base === undefined) {
+        if (resumesSession(input.passthrough))
+            return given("resume");
+        const s = loadSettings();
+        base =
+            s.map((v) => (v.env?.ANTHROPIC_MODEL ?? "").trim()).find((m) => m !== "") ??
+                s.map((v) => (v.model ?? "").trim()).find((m) => m !== "");
+        if (base === undefined)
+            return given("cc-default");
+    }
+    if (hasWindowSuffix(base))
+        return { model: explicit, reason: "suffixed" };
+    if (!supportsOneM(base))
+        return { model: explicit, reason: "unsupported" };
+    return { model: `${base}${ONE_M_SUFFIX}`, reason: "one-m", from: base };
+}
 /**
  * Claude Code's opt-in for its gateway hint headers (`x-claude-code-request-class`,
  * `x-claude-code-agent-type`, `x-claude-code-prompt-id`). CC sends them to api.anthropic.com on

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

@@ -0,0 +1,92 @@
+/**
+ * The first-run cost backtest: price each request in a Claude Code transcript at API list
+ * price, and estimate what the same request would have cost through Mnemom from the
+ * EMPIRICAL saving curve measured on paired stock-vs-Mnemom runs.
+ *
+ * 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)
+ */
+/** One billed request, deduped by message id. `t` is epoch seconds. */
+export interface Row {
+    t: number;
+    model: string;
+    inp: number;
+    cr: number;
+    cw5: number;
+    cw1h: number;
+    out: number;
+    /** false for a sidechain (Task / subagent) request inside a top-level transcript. */
+    mainThread: boolean;
+    /** true when the row came from a subagents/ transcript. */
+    subagent: boolean;
+}
+/**
+ * List prices, USD per MTok: [input, output, cache read, cache write 5m, cache write 1h].
+ * Source (verified 2026-09-30): Claude Code 2.1.285's own model registry + pricing table
+ * read out of the installed binary (models[].pricing → tier_*). Longest prefix wins; an
+ * unknown model is priced as DEFAULT_PRICE.
+ */
+export declare const PRICES: Readonly<Record<string, readonly [number, number, number, number, number]>>;
+export declare function price(model: string): readonly [number, number, number, number, number];
+/** List-price cost of one request, USD. */
+export declare function rowCost(r: Row): number;
+export declare function actualBill(rows: readonly Row[]): number;
+/** An ungoverned request's original context = its billed prompt. */
+export declare function origContext(r: Row): number;
+/**
+ * Billed requests of one transcript, deduped by message id (last copy wins, first-seen
+ * order). With `seen`, an id already billed in an earlier transcript (a resumed / forked
+ * 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)";
+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 declare function ruleRate(x: number): {
+    strategy: Strategy;
+    raw: number;
+    screen: number;
+    note: RateNote;
+};
+export interface Estimate {
+    actual: number;
+    saved: number;
+    /** The saving with the < 200k band NOT floored (audit only; never shown). */
+    rawSaved: number;
+    peak: number;
+    requests: number;
+    notes: Partial<Record<Exclude<RateNote, null>, number>>;
+}
+/** The one swap point: rows → list-price actual and the conservative saving. */
+export declare function estimate(rows: readonly Row[]): Estimate;

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

@@ -0,0 +1,196 @@
+/**
+ * The first-run cost backtest: price each request in a Claude Code transcript at API list
+ * price, and estimate what the same request would have cost through Mnemom from the
+ * EMPIRICAL saving curve measured on paired stock-vs-Mnemom runs.
+ *
+ * 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)
+ */
+import { forEachLine, isoSeconds, parseJson } from "./lines.js";
+/**
+ * List prices, USD per MTok: [input, output, cache read, cache write 5m, cache write 1h].
+ * Source (verified 2026-09-30): Claude Code 2.1.285's own model registry + pricing table
+ * read out of the installed binary (models[].pricing → tier_*). Longest prefix wins; an
+ * unknown model is priced as DEFAULT_PRICE.
+ */
+export const PRICES = {
+    "claude-opus-5-5": [4.0, 20.0, 0.2, 5.0, 8.0],
+    "claude-opus-5": [5.0, 25.0, 0.5, 6.25, 10.0],
+    "claude-opus-4": [5.0, 25.0, 0.5, 6.25, 10.0],
+    "claude-opus-4-0": [15.0, 75.0, 1.5, 18.75, 30.0],
+    "claude-opus-4-1": [15.0, 75.0, 1.5, 18.75, 30.0],
+    "claude-fable-5-1": [10.0, 50.0, 0.25, 12.5, 20.0],
+    "claude-fable-5": [10.0, 50.0, 1.0, 12.5, 20.0],
+    "claude-mythos": [10.0, 50.0, 0.25, 12.5, 20.0],
+    "claude-sonnet-5": [2.0, 10.0, 0.2, 2.5, 4.0],
+    "claude-sonnet-4": [3.0, 15.0, 0.3, 3.75, 6.0],
+    "claude-haiku-4-5": [1.0, 5.0, 0.1, 1.25, 2.0],
+    "claude-3": [3.0, 15.0, 0.3, 3.75, 6.0],
+    "claude-3-5-haiku": [0.8, 4.0, 0.08, 1.0, 1.6],
+};
+const DEFAULT_PRICE = "claude-opus-5";
+export function price(model) {
+    const m = model.replace(/\[[^\]]*\]$/, "");
+    let best = null;
+    for (const k of Object.keys(PRICES)) {
+        if (m.startsWith(k) && (best === null || k.length > best.length))
+            best = k;
+    }
+    return PRICES[best ?? DEFAULT_PRICE];
+}
+/** List-price cost of one request, USD. */
+export function rowCost(r) {
+    const [pi, po, pr, w5, w1] = price(r.model);
+    return (r.inp * pi + r.out * po + r.cr * pr + r.cw5 * w5 + r.cw1h * w1) / 1e6;
+}
+export function actualBill(rows) {
+    let s = 0;
+    for (const r of rows)
+        s += rowCost(r);
+    return s;
+}
+/** An ungoverned request's original context = its billed prompt. */
+export function origContext(r) {
+    return r.inp + r.cr + r.cw5 + r.cw1h;
+}
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+const USAGE = Buffer.from('"usage"');
+const ASSISTANT = Buffer.from('"assistant"');
+/**
+ * Billed requests of one transcript, deduped by message id (last copy wins, first-seen
+ * order). With `seen`, an id already billed in an earlier transcript (a resumed / forked
+ * session copies messages) is skipped, so each request is billed once, to its origin.
+ */
+export function loadTranscript(path, seen) {
+    const byId = new Map();
+    const subagent = path.includes("/subagents/");
+    let anon = 0;
+    forEachLine(path, (line) => {
+        if (line.indexOf(USAGE) === -1 || line.indexOf(ASSISTANT) === -1)
+            return;
+        const d = parseJson(line);
+        if (!d || d.type !== "assistant")
+            return;
+        const m = d.message;
+        if (!m || typeof m !== "object")
+            return;
+        const u = m.usage;
+        if (!u || typeof u !== "object")
+            return;
+        const model = typeof m.model === "string" ? m.model : "";
+        if (!model || model.startsWith("<"))
+            return;
+        const t = isoSeconds(d.timestamp);
+        if (t === null)
+            return;
+        const cc = u.cache_creation ?? {};
+        const cw = num(u.cache_creation_input_tokens);
+        const cw1h = num(cc.ephemeral_1h_input_tokens);
+        // Older Claude Code versions omit the 5m split (or the whole cache_creation object):
+        // derive 5m as total − 1h, and never let a reported 5m share leave writes unbilled.
+        const cw5 = Math.max(num(cc.ephemeral_5m_input_tokens), cw - cw1h);
+        const id = (typeof m.id === "string" && m.id) ||
+            (typeof d.uuid === "string" && d.uuid) ||
+            `anon-${path}-${anon++}`;
+        byId.set(id, {
+            t,
+            model,
+            inp: num(u.input_tokens),
+            cr: num(u.cache_read_input_tokens),
+            cw5: Math.max(cw5, 0),
+            cw1h,
+            out: num(u.output_tokens),
+            mainThread: d.isSidechain !== true,
+            subagent,
+        });
+    });
+    const out = [];
+    for (const [id, row] of byId) {
+        if (seen) {
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+        }
+        out.push(row);
+    }
+    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`). */
+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" };
+    }
+    const r = CURVE_LOWER.aggressive[binOf(x)];
+    return { strategy: "aggressive", raw: r, screen: r, note: null };
+}
+/** The one swap point: rows → list-price actual and the conservative saving. */
+export function estimate(rows) {
+    let actual = 0;
+    let saved = 0;
+    let rawSaved = 0;
+    let peak = 0;
+    const notes = {};
+    for (const r of rows) {
+        const x = origContext(r);
+        if (x > peak)
+            peak = x;
+        const rate = ruleRate(x);
+        const c = rowCost(r);
+        actual += c;
+        saved += rate.screen * c;
+        rawSaved += rate.raw * c;
+        if (rate.note)
+            notes[rate.note] = (notes[rate.note] ?? 0) + 1;
+    }
+    return { actual, saved, rawSaved, peak, requests: rows.length, notes };
+}

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

@@ -0,0 +1,65 @@
+/**
+ * Did a Claude Code transcript already run through Mnemom? A session is GOVERNED — and
+ * left out of the first-run look — if ANY signal fires. When in doubt, exclude.
+ *
+ *   registry_cc_id     the transcript's session id is a `cc_session_id` in the launch
+ *                      ledger (~/.mnemom/sessions.jsonl, lib/agent-ledger.ts)
+ *   registry_conv_id   … or a ledger `conversation_id`
+ *   registry_window    its first event is within [launch-60s, launch+10min] of a ledger
+ *                      launch that recorded no cc_session_id (--server, older rows)
+ *   rc_proxy_window    the same window match against a Remote Control proxy log
+ *   text_marker        the bytes carry a gateway marker ('[mnemom', 'x-mnemom', 'covers=',
+ *                      …). Also fires on sessions that merely DISCUSS Mnemom: over-excludes,
+ *                      the safe direction
+ *   settings_env       a settings file (global or the session cwd's) or the transcript
+ *                      text points ANTHROPIC_BASE_URL / HTTPS_PROXY at a mnemom host or a
+ *                      localhost proxy
+ *   agent_sdk_host     entrypoint sdk-py / sdk-ts: an Agent-SDK host can route through
+ *                      the gateway with env no transcript records
+ *   (a session is governed if its top transcript OR any subagent transcript fires)
+ *
+ * Read-only on ~/.claude and ~/.mnemom. No network.
+ */
+export declare const AGENT_SDK_ENTRYPOINTS: Set<string>;
+/** Lowercase byte markers. Candidate lines are found by the case-variant probes below. */
+export declare const TEXT_MARKERS: string[];
+export declare function lineHasMarker(line: Buffer): boolean;
+export declare function lineHasEnv(line: Buffer): boolean;
+export interface FileHead {
+    firstTs: number | null;
+    cwd: string | null;
+    sessionId: string | null;
+    entrypoint: string | null;
+}
+export interface FileResult extends FileHead {
+    signals: string[];
+}
+export interface GovernanceInputs {
+    home?: string;
+    /** Directory holding the launch ledger (MNEMOM_DIR). */
+    mnemomDir?: string;
+    tmp?: string;
+}
+/** Session id of a transcript path: its own uuid, or the parent's for a subagent file. */
+export declare function sessionIdFor(path: string): string;
+export declare class Governance {
+    readonly ccIds: Set<string>;
+    readonly convIds: Set<string>;
+    readonly windows: Array<["registry_window" | "rc_proxy_window", number]>;
+    readonly globalSettingsEnv: boolean;
+    registryRows: number;
+    private readonly cwdCache;
+    constructor(inp?: GovernanceInputs);
+    private cwdEnv;
+    /** The first records of a file: first timestamp, cwd, session id, entrypoint. */
+    head(path: string, maxBytes?: number): FileHead;
+    /** Signals that follow from a file's head records alone. */
+    private headSignals;
+    /**
+     * Classify one transcript. The cheap signals (ledger, head records, settings, windows)
+     * are checked first; the full byte scan for markers runs only when none fired (the
+     * session is excluded either way, so the scan would change nothing). The full scan
+     * also completes head fields that a large first record pushed past the head read.
+     */
+    classify(path: string): FileResult;
+}