loopmath 0.2.7__py3-none-any.whl → 0.2.8__py3-none-any.whl

loopmath/__init__.py

@@ -5,4 +5,4 @@ The command line (`loopmath`, or its alias `loop`) is the interface; see the
 README and `loopmath --help`.
 """
 
-__version__ = "0.2.7"
+__version__ = "0.2.8"

loopmath/belief/compose.py

@@ -18,6 +18,13 @@ simulated per draw (run noise and gate outcomes), and the interval is its 10th a
 percentiles. Rounds, success and `ell` are parameter-draw quantities. Without a generator,
 `compose` computes the expectations only (the mean path in state.py).
 
+Tokens (0.2.8): one execution's dollars are `U = exp(eta_u + sigma_u z1)` and its price per token
+`R = exp(eta_r + sigma_r z2)`, from the rate head; its tokens are `T = U / max(R, f)`, with `f` the model's
+cache-read rate (its floor, none for a model without one). So `T f <= U` in every draw, and every shown pair of
+dollars and tokens clears the floor: per draw, in the mean, at every percentile and summed over pieces. The two
+normals are drawn in 0.2.7's order (dollars, then the second one), so the simulated dollars and the gates after
+them are 0.2.7's. The expected tokens are `E[U] E[1 / max(R, f)]` (`inv_rate_mean`).
+
 Per piece, `PieceDraws.exp_*` is the piece's expected full-run contribution, summed over
 the rounds it runs, so pieces add up to the run. `cost_per_round()` gives the expected cost of
 one execution: the per-execution prediction when the piece's cost does not depend on the round
@@ -28,8 +35,11 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 
+import math
+from collections.abc import Mapping
+
 import numpy as np
-from scipy.special import expit
+from scipy.special import expit, log_ndtr
 
 from .design import Structure
 
@@ -64,12 +74,33 @@ class RunDraws:
     reach: dict[tuple[str, int], np.ndarray] = field(default_factory=dict)  # (piece, k) -> P(piece runs in round k)
 
 
-def compose(st: Structure, cost_eta: dict, tokens_eta: dict, gate_eta: dict, *, sigma_usd: float,
-            sigma_tokens: float, rng: np.random.Generator | None) -> RunDraws:
-    """Compose one configuration. `*_eta[(piece, k)]` and `gate_eta[(gate index, k)]` are draw arrays.
-    With `rng` None nothing is simulated: the `sim_*` arrays stay zero."""
+def inv_rate_mean(m, v, floor: float | None) -> np.ndarray:
+    """`E[1 / max(R, f)]` for `log R ~ N(m, v)` and the floor `f` ($ per token; None or 0: no floor), per entry
+    of `m`. With `l = log f`: `exp(-m + v/2) Phi((m - l)/sqrt(v) - sqrt(v)) + exp(-l) Phi((l - m)/sqrt(v))`,
+    each term in logs (`log Phi`), so a far tail never multiplies an overflow by 0. With `v = 0` the rate is
+    certain: `1 / max(exp(m), f)`."""
+    m = np.asarray(m, float)
+    v = np.broadcast_to(np.asarray(v, float), m.shape)
+    if not floor or floor <= 0:
+        return np.exp(-m + 0.5 * v)
+    lf = math.log(floor)
+    certain = v <= 0
+    sd = np.sqrt(np.where(certain, 1.0, v))
+    spread = np.exp(-m + 0.5 * v + log_ndtr((m - lf) / sd - sd)) + np.exp(log_ndtr((lf - m) / sd) - lf)
+    return np.where(certain, np.exp(-np.maximum(m, lf)), spread)
+
+
+def compose(st: Structure, cost_eta: dict, rate_eta: dict, gate_eta: dict, *, sigma_usd: float,
+            sigma_rate: float, floors: Mapping[str, float] | None = None, rate_var: Mapping | None = None,
+            rng: np.random.Generator | None) -> RunDraws:
+    """Compose one configuration. `cost_eta[(piece, k)]`, `rate_eta[(piece, k)]` and `gate_eta[(gate index, k)]`
+    are draw arrays; `floors[piece]` is the piece model's floor in $ per token (absent or 0: none). The expected
+    tokens take `log R ~ N(rate_eta, rate_var[(piece, k)])`, `sigma_rate ** 2` when `rate_var` is None (the mean
+    path passes the rate rows' known parts and adds their unseen variance there). With `rng` None nothing is
+    simulated: the `sim_*` arrays stay zero."""
     n = len(next(iter(cost_eta.values())))
-    half_u, half_t = 0.5 * sigma_usd ** 2, 0.5 * sigma_tokens ** 2
+    half_u, var_r = 0.5 * sigma_usd ** 2, sigma_rate ** 2
+    floors = floors or {}
     exp_u, exp_t = np.zeros(n), np.zeros(n)
     sim_u, sim_t = np.zeros(n), np.zeros(n)
     rounds = np.ones(n)
@@ -79,7 +110,7 @@ def compose(st: Structure, cost_eta: dict, tokens_eta: dict, gate_eta: dict, *,
         pieces[p] = PieceDraws(np.zeros(n), np.zeros(n), np.zeros(n), np.zeros(n), np.ones(n), sim_runs=np.zeros(n))
         if st.piece_loop.get(p) is not None:
             pieces[p].round_free = all(
-                np.array_equal(cost_eta[(p, k)], cost_eta[(p, 1)]) and np.array_equal(tokens_eta[(p, k)], tokens_eta[(p, 1)])
+                np.array_equal(cost_eta[(p, k)], cost_eta[(p, 1)]) and np.array_equal(rate_eta[(p, k)], rate_eta[(p, 1)])
                 for k in range(2, st.k_max + 1))
     gate_after = {g.after: gi for gi, g in enumerate(st.gates)}
     for piece, gi in gate_after.items():
@@ -88,17 +119,20 @@ def compose(st: Structure, cost_eta: dict, tokens_eta: dict, gate_eta: dict, *,
 
     def run_piece(piece: str, k: int, weight: np.ndarray, alive: np.ndarray):
         w = st.widths[piece]
-        eu, et = cost_eta[(piece, k)], tokens_eta[(piece, k)]
+        eu, er = cost_eta[(piece, k)], rate_eta[(piece, k)]
+        f = float(floors.get(piece) or 0.0)
         cu = w * np.exp(eu + half_u)
-        ct = w * np.exp(et + half_t)
+        ct = cu * inv_rate_mean(er, var_r if rate_var is None else rate_var[(piece, k)], f)
         pd = pieces[piece]
         pd.exp_usd += weight * cu
         pd.exp_tokens += weight * ct
         su = np.zeros(n)
         stt = np.zeros(n)
         for _ in range(w if rng is not None else 0):
-            su += np.exp(eu + sigma_usd * rng.standard_normal(n))
-            stt += np.exp(et + sigma_tokens * rng.standard_normal(n))
+            u = np.exp(eu + sigma_usd * rng.standard_normal(n))
+            r = np.exp(er + sigma_rate * rng.standard_normal(n))
+            su += u
+            stt += u / (np.maximum(r, f) if f > 0 else r)
         pd.sim_usd += alive * su
         pd.sim_tokens += alive * stt
         pd.sim_runs += alive

loopmath/belief/design.py

@@ -30,8 +30,12 @@ from .pricing import price_term
 Term = tuple[str, "str | None", float]
 
 # Node names of this design (spec 04 section 4). 2 (loopmath 0.2): shape keys, psrc nodes and role groups.
-# 3 (0.2): `horizon:log2h` is relative to the fit's reference horizon. A fit of another version is not read.
-DESIGN_VERSION = 3
+# 3 (0.2): `horizon:log2h` is relative to the fit's reference horizon. 4 (0.2.8): a `rate` head on the price
+# per token replaces the tokens head. A fit of another version is not read.
+DESIGN_VERSION = 4
+# The version the seed key hashes (spec 04 section 3). It stays 3 from 0.2.8: the same data seeds the same
+# draws as in 0.2.7, so every number that is not a token count is 0.2.7's.
+SEED_VERSION = 3
 HEURISTIC_COST_WEIGHT = 0.7  # spec 04 section 2 and D27: allocated (heuristic) cost rows
 USER_SOURCES = ("live", "backlog", "history", "user", "orchestrator", "onboard", "habit", "")
 HORIZON_NODES = ("horizon:timebox", "horizon:log2h")  # fixed terms of a timeboxed run (spec 04 section 1)

loopmath/belief/features.py

@@ -35,6 +35,8 @@ LN2 = math.log(2.0)
 # cost and tokens scale with an elasticity of 1 +- 0.5; logit and score heads start flat.
 HORIZON_PRIOR = {
     "cost": {"horizon:log2h": (LN2, 0.35), "horizon:timebox": (0.0, 1.5)},
+    # the price per token (0.2.8): a longer horizon buys more tokens, not dearer ones
+    "rate": {"horizon:log2h": (0.0, 0.35), "horizon:timebox": (0.0, 1.5)},
     "logit": {"horizon:log2h": (0.0, 0.25), "horizon:timebox": (0.0, 1.0)},
     "score": {"horizon:log2h": (0.0, 0.25), "horizon:timebox": (0.0, 1.0)},
 }

loopmath/belief/fit.py

@@ -31,12 +31,12 @@ from scipy import sparse
 from ..taskmodel import FeatureConfigError, FeatureSet
 from . import design as design_rows
 from . import priors as prior_data
-from .design import (DESIGN_VERSION, Term, Unusable, cost_row, gate_row, parse_run, run_row, structure,
-                     task_features, task_terms)
+from .design import (DESIGN_VERSION, SEED_VERSION, Term, Unusable, cost_row, gate_row, parse_run, run_row,
+                     structure, task_features, task_terms)
 from .features import FeatureTally, add_horizon, drop_features, horizon_nodes, horizon_specs
 from .block import leaf_split
 from .forest import Forest, default_scale, fixed_sd, scale_group
-from .pricing import PRICE_NODE, PRICE_PRIOR_SD, STREAMS, fit_offsets, price_term
+from .pricing import PRICE_NODE, PRICE_PRIOR_SD, STREAMS, fit_offsets, price_term, rate_floors
 from .gaussian import N_DRAWS, Factors, GaussianHead, HeadFit, LogisticHead, Prior
 from .state import SCORE_CLAMP, inverse_transform, transform  # noqa: F401  (re-exported)
 
@@ -44,8 +44,12 @@ FIT_LOCK = ".fit.lock"
 KEEP_FITS = 5  # The newest fits kept, besides the ones a receipt or stored recommendation names
 TASK_LEVELS = ("org", "type", "repo", "subtype", "task")
 MIN_SCORE_RUNS = 3  # spec 04 section 2: a score head needs at least 3 measured runs
-HEAD_KIND = {"cost": ("gaussian", "cost"), "tokens": ("gaussian", "cost"),
+# `tokens` (log tokens) is 0.2.7's head: from 0.2.8 its rows are built for the seed key and the node index
+# only, never fitted. `rate` (log usd - log tokens, the price per token) is fitted in its place (spec 04 section 2).
+HEAD_KIND = {"cost": ("gaussian", "cost"), "tokens": ("gaussian", "cost"), "rate": ("gaussian", "cost"),
              "gate": ("logistic", "logit"), "success": ("logistic", "logit")}
+KEY_ONLY = ("tokens",)  # heads whose rows the seed key and the node index read, and no fit
+NOT_KEYED = ("rate",)  # heads the seed key leaves out, so 0.2.8 seeds every draw as 0.2.7 did
 
 
 class FitBusy(RuntimeError):
@@ -273,6 +277,9 @@ def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tup
                     acc[i] += v
             if a.tokens:
                 heads["tokens"].add(terms, math.log(a.tokens), a.weight, pr.run_id, pr.source, ttype)
+            if a.usd and a.tokens:
+                heads["rate"].add(terms, math.log(a.usd) - math.log(a.tokens), a.weight, pr.run_id, pr.source,
+                                  ttype)
         for gi, k, passed in pr.gates:
             heads["gate"].add(gate_row(pr.task, pr.source, st, st.gates[gi], k, features), 1.0 if passed else 0.0,
                               1.0, pr.run_id, pr.source, ttype)
@@ -305,6 +312,8 @@ def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tup
     for hr in heads.values():
         hr.rows = add_horizon(drop_features(hr.rows, tally.nodes), hr.runs, tally.run_horizon, coding)
     add_prices(heads["cost"], {m: len(r) for m, r in model_runs.items()}, model_streams)
+    heads["rate"].prices = heads["cost"].prices  # the price per token carries the same offset (spec 04 section 2)
+    _price_rows(heads["rate"])
     return (heads, score_info, dict(dropped), dict(runs_by_source), {c: dict(n) for c, n in config_support.items()},
             dict(checks), dict(overlap), dict(labels), tally)
 
@@ -313,7 +322,12 @@ def add_prices(hr: HeadRows, runs: dict[str, int], streams: dict[str, list[float
     """The price offset (spec 04 section 2): the fit's offsets from its runs and token mix under the current price
     table, and each cost row with its model's `price:offset` term (`pricing.price_term`, as at prediction)."""
     hr.prices = fit_offsets(runs, streams, design_rows._price_table())
-    offsets = hr.prices["models"]
+    _price_rows(hr)
+
+
+def _price_rows(hr: HeadRows) -> None:
+    """Each row with its model's `price:offset` term under `hr.prices`."""
+    offsets = hr.prices.get("models")
     if not offsets:
         return
     rows = []
@@ -325,10 +339,11 @@ def add_prices(hr: HeadRows, runs: dict[str, int], streams: dict[str, list[float
 
 
 def price_spec(hr: HeadRows) -> list:
-    """The prior that holds `price:offset` at 1, on the cost head of a fit with offsets, --no-prior included."""
+    """The prior that holds `price:offset` at 1, on the cost and rate heads of a fit with offsets, --no-prior
+    included."""
     if not hr.prices.get("models"):
         return []
-    return [prior_data.FactorSpec("cost", [(PRICE_NODE, None, 1.0)], 1.0, PRICE_PRIOR_SD ** 2,
+    return [prior_data.FactorSpec(hr.name, [(PRICE_NODE, None, 1.0)], 1.0, PRICE_PRIOR_SD ** 2,
                                   f"{PRICE_NODE} held at 1, prior N(1, {PRICE_PRIOR_SD}^2)")]
 
 
@@ -417,18 +432,21 @@ def seed_for(fit_id: str, head: str) -> int:
 
 
 def input_key(heads_rows: dict[str, HeadRows], specs: list, settings: dict) -> str:
-    """The fit's `seed_key` (spec 04 section 3): the sha256 of the design version, the settings that change the
+    """The fit's `seed_key` (spec 04 section 3): the sha256 of the seed version, the settings that change the
     posterior, the prior factors and every head's rows (terms, response, weight, run, source), each head's rows
     sorted, so the same data and settings seed the same draws whatever the store's reading order.
 
     A success row's weight is its q. With `outcome.q` configured, the key takes each row's q under the built-in
-    map (`HeadRows.seed_w`), so setting q redraws nothing: only the success head's posterior moves (0.2.7)."""
+    map (`HeadRows.seed_w`), so setting q redraws nothing: only the success head's posterior moves (0.2.7).
+
+    From 0.2.8 the key reads 0.2.7's heads: the tokens rows, which no head fits any more, and not the rate rows,
+    with the seed version 0.2.7 hashed as its design version. The same data seeds the same draws as in 0.2.7."""
     h = hashlib.sha256()
-    h.update(repr((DESIGN_VERSION, design_rows.TIMEBOX_EFFORT_COST, design_rows.TIMEBOX_LEVELS,
+    h.update(repr((SEED_VERSION, design_rows.TIMEBOX_EFFORT_COST, design_rows.TIMEBOX_LEVELS,
                    sorted(settings.items()))).encode())
     for spec in specs:
         h.update(repr((spec.head, spec.terms, spec.mean, spec.var)).encode())
-    for name in sorted(heads_rows):
+    for name in sorted(n for n in heads_rows if n not in NOT_KEYED):
         hr = heads_rows[name]
         h.update(f"\n{name}:{len(hr.rows)}".encode())
         weights = hr.seed_w or hr.w
@@ -618,9 +636,12 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
                 continue
             nodes = horizon_nodes(hr.rows)
             if nodes:  # the horizon priors, --no-prior included (spec 04 section 1)
-                head_specs += horizon_specs(name, hr.kind, nodes)
-            if name == "cost":  # the price offset (spec 04 section 2)
+                head_specs += horizon_specs(name, "rate" if name == "rate" else hr.kind, nodes)
+            if name in ("cost", "rate"):  # the price offset (spec 04 section 2)
                 head_specs += price_spec(hr)
+            if name in KEY_ONLY:  # 0.2.7's tokens head: its nodes enter the index where they did, unfitted
+                build_matrix(hr.rows, forest, [(n, p) for spec in head_specs for n, p, _ in spec.terms])
+                continue
             fitted[name] = fit_head(hr, forest, head_specs, eb=eb)
         fit_id = new_fit_id(fits, now)
         partial = fits / f"{fit_id}.partial"
@@ -685,6 +706,8 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
             "features": {**tally.report, **({"error": features_error} if features_error else {})},
             "horizons": tally.horizon_report(),
             "price_offsets": heads_rows["cost"].prices,
+            # the cheapest rate of each priced model, $ per token: a draw's tokens never cost less (spec 04 section 3)
+            "rate_floors": rate_floors(design_rows._price_table()),
         }
         if full:
             meta["full"] = _full_check(fitted)

loopmath/belief/lookahead.py

@@ -394,7 +394,7 @@ def _condition_head(head: HeadState, terms: Sequence[tuple], tau2: float) -> Hea
 def conditioned(state: FitState, task: Task, config: Configuration, rule: AcceptanceRule | None = None) -> FitState:
     heads = dict(state.heads)
     terms, n_obs = _explore_cost_obs(state, task, config)
-    for name in ("cost", "tokens"):
+    for name in ("cost", "rate"):
         heads[name] = _condition_head(state.heads[name], terms, state.heads[name].sigma ** 2 / n_obs)
     run_terms = state.task_terms(task) + list(state._plan(config)["run"])
     succ = state.heads["success"]

loopmath/belief/pricing.py

@@ -1,7 +1,8 @@
-"""The price offset on the cost head (spec 04 section 2, 0.2.2).
+"""The price offset on the cost and rate heads (spec 04 section 2, 0.2.2), and the rate floors (0.2.8).
 
-A model's run cost moves with its list price. Every cost row of a model version `m` (not the tokens, gate,
-success or score rows) carries the fixed term `price:offset` with the value
+A model's run cost moves with its list price. Every cost row of a model version `m`, and from 0.2.8 every rate
+row (the price per token), carries the fixed term `price:offset` (not the gate, success or score rows), with
+the value
 
     o_m = s_m * log(P_m / R_m),   s_m = n0 / (n0 + n_m),
 
@@ -18,6 +19,10 @@ the same at fit and at prediction:
 
 `fit_offsets` computes the offset of every model with cost rows and of every model in the price table once per
 fit; `meta.json` `price_offsets` stores them, and prediction and the workflow search read them from there.
+
+`rate_floors` gives each priced model's cache-read rate in $ per token, the cheapest rate any of its tokens
+bills at (in every row of the packaged table, no nonzero rate is lower). A draw's price per token is held at or
+above it, so its tokens never cost less than its dollars (spec 04 section 3). `meta.json` stores them too.
 """
 
 from __future__ import annotations
@@ -140,3 +145,17 @@ def price_term(offsets: Mapping[str, float] | None, model: str) -> tuple[tuple[s
         return ()
     o = offsets.get(model)
     return ((PRICE_NODE, None, float(o)),) if o else ()
+
+
+def rate_floors(table) -> dict[str, float]:
+    """Model (canonical id) to its cache-read rate in $ per token, for every model with a positive one; empty
+    without a table. Two table keys of one model keep the lower rate."""
+    out: dict[str, float] = {}
+    if table is None:
+        return out
+    for key, rate in table.rates.items():
+        floor = float(rate.get("cache_read") or 0.0) / 1e6
+        if floor > 0:
+            model = canonical_model_id(key)
+            out[model] = min(floor, out.get(model, floor))
+    return dict(sorted(out.items()))

loopmath/belief/state.py

@@ -16,15 +16,21 @@ Prediction:
   (setting, role, topology, position, round, control) is cached per fit, so `predict_many`
   over thousands of candidates reuses rows.
 - The composition (compose.py) runs over the draws. Cost intervals are predictive.
-- Means do not sample the unseen nodes: their effects are normal, so each cost and
-  tokens row's expected cost is log-normal in closed form over the known draws, the unseen
-  task effect on the gates (one normal shared by every gate row of the task) and on success
-  or a score are integrated by Gauss-Hermite, and a score's reach chance is a normal CDF.
+- Tokens (0.2.8): a draw's tokens are its dollars over its price per token (the rate head),
+  the rate held at or above the model's cache-read rate (`meta.rate_floors`), so no shown
+  tokens cost less than the dollars beside them (compose.py).
+- Means do not sample the unseen nodes: their effects are normal, so each cost row's
+  expected cost is log-normal in closed form over the known draws, and the expected tokens
+  are that times `E[1 / max(R, f)]` with the rate row's unseen variance added to its own
+  (`compose.inv_rate_mean`). The unseen task effect on the gates (one normal shared by every
+  gate row of the task) and on success or a score are integrated by Gauss-Hermite, and a
+  score's reach chance is a normal CDF.
   The `ell.tokens` mean prices the rescue at each draw's own tokens per dollar, as its draws
-  do: `E[1 / C_run]` is integrated over every unseen cost effect, the task's and each piece's
-  (a new model, role or position), in closed form when the pieces share them and otherwise
-  over their differences, by Gauss-Hermite up to four axes and a fixed Sobol set beyond, never
-  more than 256 points.
+  do: `E[T_run / C_run]`, the mean of the run's tokens per dollar, an average of each group's
+  (pieces with the same unseen cost nodes) weighted by its cost (`_tokens_per_usd`). It is
+  integrated over every unseen cost effect, the task's and each piece's (a new model, role or
+  position): exact when the pieces share them (the task's cancels), otherwise over their
+  differences, by Gauss-Hermite up to four axes and a fixed Sobol set beyond, never more than 256 points.
   A new task's means therefore do not depend on its id, and the Monte Carlo error of 400
   seeded draws of a large unseen effect (task, repo, org) leaves them. Intervals, the draws
   (`success_draws`, `ell_draws`) and the simulated runs keep the sampled effects. Unseen
@@ -57,14 +63,14 @@ from ..types import (
 )
 from .compose import Intervals, RunDraws, compose, cost_per_round, interval
 from .design import Structure, cost_rest, gate_rest, other_design, run_rest, structure, task_features, task_terms
-from .forest import LEVEL_ALIASES, default_scale, display_level, level_of, node_key, scale_group
+from .forest import LEVEL_ALIASES, canonical_model_id, default_scale, display_level, level_of, node_key, scale_group
 from .block import BlockFactor, blocks, leading_diagonal
 from .gaussian import _cho, cov_factor
 
 N_DRAWS = 400
 PREDICT_SOURCE = "user"
 MIN_SCORE_SWITCH = 5  # spec 04 section 2: g = p_reach once the score head has 5 runs in the task's type
-BASE_HEADS = {"cost": ("gaussian", "cost"), "tokens": ("gaussian", "cost"), "gate": ("logistic", "logit"),
+BASE_HEADS = {"cost": ("gaussian", "cost"), "rate": ("gaussian", "cost"), "gate": ("logistic", "logit"),
               "success": ("logistic", "logit")}
 TASK_CHAIN = ("task", "subtype", "repo", "type")
 FIXED_LEVELS = ("fixed", "round", "control", "price")
@@ -123,7 +129,7 @@ def normal_mean(f: Callable[[np.ndarray], np.ndarray], eta: np.ndarray, s2: floa
 MAX_POINTS = 256  # The most points `_rule` gives, whatever the number of axes
 _GRID_NODES = {1: MEAN_NODES, 2: 8, 3: 6, 4: 4}  # Gauss-Hermite nodes per axis; nodes ** k <= MAX_POINTS
 _SOBOL_SEED = 106
-_CHUNK = 64  # points evaluated at once in `_inv_cost`
+_CHUNK = 64  # points evaluated at once in `_ratio_mean`
 
 
 @lru_cache(maxsize=32)
@@ -146,6 +152,32 @@ def _rule(k: int) -> tuple[np.ndarray, np.ndarray]:
     return ndtri(u), np.full(MAX_POINTS, 1.0 / MAX_POINTS)
 
 
+
+def _ratio_mean(A: np.ndarray, B: np.ndarray, L: np.ndarray) -> np.ndarray:
+    """`E[sum_i B_i exp(L_i . z) / sum_i A_i exp(L_i . z)]` per column of `A` and `B` (groups by entries), `z`
+    standard normal: a mean of the `B_i / A_i` weighted by `A_i exp(L_i . z)`, so it lies between their least and
+    greatest. Against a reference group `r` the ratio depends only on `d = (L_G - L_r) . z ~ N(0, Cov(d))`,
+    integrated on the principal axes of `Cov(d)` by `_rule`: at most `MAX_POINTS` points, evaluated `_CHUNK` at a
+    time, so memory and work stay bounded for any number of pieces. The reference is the group with the largest
+    cost. With one group the ratio is `B / A`."""
+    ref = int(np.argmax(A.mean(axis=1)))
+    others = [i for i in range(len(A)) if i != ref]
+    if not others:
+        return np.divide(B[ref], A[ref], out=np.zeros_like(A[ref]), where=A[ref] > 0)
+    D = L[others] - L[ref]
+    w, V = np.linalg.eigh(D @ D.T)
+    keep = w > 1e-12 * max(float(w.max()), 1e-300)
+    pts, wts = _rule(int(keep.sum()))
+    axes = (V[:, keep] * np.sqrt(w[keep]))[:, ::-1]  # the largest axis first
+    out = np.zeros(A.shape[1])
+    for i in range(0, len(wts), _CHUNK):
+        E = np.exp(pts[i:i + _CHUNK] @ axes.T)
+        S = A[ref][None, :] + E @ A[others]
+        N = B[ref][None, :] + E @ B[others]
+        out += wts[i:i + _CHUNK] @ np.divide(N, S, out=np.zeros_like(S), where=S > 0)
+    return out
+
+
 class HeadState:
     """One head's posterior: node ids, mean, covariance factor and joint draws (lazy).
 
@@ -341,6 +373,8 @@ class FitState:
         self.timebox_effort = float(self.meta.get("timebox_effort", 1.0))
         # spec 04 section 2: the fit's price offset per model (log scale); none in fits before 0.2.2
         self.price_offsets: dict[str, float] = dict((self.meta.get("price_offsets") or {}).get("models") or {})
+        # spec 04 section 3 (0.2.8): each priced model's cache-read rate, $ per token; a draw's rate stays above it
+        self.rate_floors: dict[str, float] = dict(self.meta.get("rate_floors") or {})
         if heads is None:
             heads = {}
             for name, hmeta in (self.meta.get("heads") or {}).items():
@@ -426,7 +460,9 @@ class FitState:
         for gi, g in enumerate(st.gates):
             for k in range(1, (st.k_max if st.gate_loop.get(gi) is not None else 1) + 1):
                 gate[(gi, k)] = gate_rest(st, g, k)
-        return {"config": config, "st": st, "cost": cost, "gate": gate, "run": run_rest(st)}
+        floors = {piece: float(self.rate_floors.get(canonical_model_id(st.settings[piece].model), 0.0))
+                  for piece in st.pieces}
+        return {"config": config, "st": st, "cost": cost, "gate": gate, "run": run_rest(st), "floors": floors}
 
     # ------------------------------------------------------------ the task as the fit reads it
 
@@ -554,7 +590,7 @@ class FitState:
         gate_keys = [k for p in plans for k in p["gate"].values()]
         run_keys = [p["run"] for p in plans]
         self._cached(self.heads["cost"], cost_keys)
-        self._cached(self.heads["tokens"], cost_keys)
+        self._cached(self.heads["rate"], cost_keys)
         if gate_keys:
             self._cached(self.heads["gate"], gate_keys)
         for name, head in self.heads.items():
@@ -652,8 +688,9 @@ class FitState:
         """The composition's expectations with the unseen effects integrated out, and the map
         from its arrays to one value per known draw.
 
-        A cost or tokens row enters the composition only through `exp(eta)`, times weights that
-        depend on the gates alone, so its unseen effect `N(0, s2)` becomes `eta + s2 / 2`. The
+        A cost row enters the composition only through `exp(eta)`, times weights that depend on
+        the gates alone, so its unseen effect `N(0, s2)` becomes `eta + s2 / 2`. A rate row enters
+        through `E[1 / max(R, f)]`: its known part goes in with the variance `sigma^2 + s2`. The
         unseen task effect on the gates is one normal added to every gate row, integrated by
         Gauss-Hermite (the loop's reach is not linear in it): the draws are tiled once per node.
         """
@@ -665,7 +702,10 @@ class FitState:
             return known + 0.5 * s2
 
         cost = {k: lognormal("cost", r) for k, r in plan["cost"].items()}
-        tok = {k: lognormal("tokens", r) for k, r in plan["cost"].items()}
+        rate, rate_var = {}, {}
+        for k, r in plan["cost"].items():
+            rate[k], s2 = self._known(heads["rate"], tparts["rate"], r)
+            rate_var[k] = heads["rate"].sigma ** 2 + s2
         tg: Row = tparts["gate"]
         gate = {k: tg.known + self._row(heads["gate"], r).draws for k, r in plan["gate"].items()}
         nodes = MEAN_NODES if gate and tg.s2 > 0 else 1
@@ -673,57 +713,45 @@ class FitState:
             shift = math.sqrt(tg.s2) * _GX[:, None]
             gate = {k: (v[None, :] + shift).ravel() for k, v in gate.items()}
             cost = {k: np.tile(v, nodes) for k, v in cost.items()}
-            tok = {k: np.tile(v, nodes) for k, v in tok.items()}
-        run = compose(st, cost, tok, gate, sigma_usd=heads["cost"].sigma, sigma_tokens=heads["tokens"].sigma, rng=None)
+            rate = {k: np.tile(v, nodes) for k, v in rate.items()}
+        run = compose(st, cost, rate, gate, sigma_usd=heads["cost"].sigma, sigma_rate=heads["rate"].sigma,
+                      floors=plan["floors"], rate_var=rate_var, rng=None)
         if nodes == 1:
             return run, lambda a: a
         return run, lambda a: _GW @ np.reshape(a, (nodes, -1))
 
-    def _inv_cost(self, plan: dict, tparts: dict, mr: RunDraws) -> np.ndarray:
-        """`E[1 / C_run]` per entry of the mean composition `mr`, every unseen cost effect
+    def _tokens_per_usd(self, plan: dict, tparts: dict, mr: RunDraws) -> np.ndarray:
+        """`E[T_run / C_run]` per entry of the mean composition `mr`, every unseen cost and rate effect
         integrated out (the task's, and a new model's, role's or position's).
 
         `C_run = sum over pieces of A_p exp(u_p)`: `A_p` is the piece's expected cost at its known
         nodes (its `mr` cost without the log-normal factor), `u_p` its unseen effect. Every round of
         a piece has the same unseen nodes (round and control terms are fixed effects), and pieces
-        with the same unseen nodes form one group. The task part is common to every group and
-        gives `exp(s2 / 2)`. With one group, `E[1 / C] = exp(Var(u) / 2) / A` exactly. Otherwise,
-        with `d_G = u_G - u_r` against a reference group `r`, a change of measure gives
-        `E[1 / C] = exp(Var(u_r) / 2) E[1 / (A_r + sum A_G exp(d_G))]`, `d ~ N(-Cov(d, u_r), Cov(d))`,
-        integrated on the principal axes of `Cov(d)` by `_rule`: at most `MAX_POINTS` points,
-        evaluated `_CHUNK` at a time, so memory and work stay bounded for any number of pieces.
-        The reference is the group with the largest cost, which bounds the integrand by
-        `1 / A_r`.
+        with the same unseen nodes form one group G. A piece's tokens are its cost times
+        `Q = 1 / max(R, f)`, and Q is independent of every cost effect, so given those effects the run's
+        tokens are `sum over G of B_G exp(u_G)`, `B_G` the group's `mr` tokens without the same factor.
+        So `E[T / C] = E[sum B_G exp(u_G) / sum A_G exp(u_G)]`: the run's tokens per dollar, the groups'
+        `B_G / A_G` weighted by their cost. The task's unseen effect is common and cancels; with one group
+        this is `B / A`. `_ratio_mean` integrates the rest.
         """
         head = self.heads["cost"]
+        s2 = tparts["cost"].s2
         groups: dict[tuple, np.ndarray] = {}
+        tokens: dict[tuple, np.ndarray] = {}
         for piece in plan["st"].pieces:
             load = self._unseen(head, plan["cost"][(piece, 1)])
-            a = mr.pieces[piece].exp_usd * math.exp(-0.5 * (tparts["cost"].s2 + sum(b * b for _, b in load)))
+            known = math.exp(-0.5 * (s2 + sum(b * b for _, b in load)))
+            a = mr.pieces[piece].exp_usd * known
+            t = mr.pieces[piece].exp_tokens * known
             groups[load] = groups[load] + a if load in groups else a
+            tokens[load] = tokens[load] + t if load in tokens else t
         loads = list(groups)
-        A = np.stack([groups[g] for g in loads])
         names = {n: j for j, n in enumerate(sorted({n for g in loads for n, _ in g}))}
         L = np.zeros((len(loads), len(names)))
         for i, g in enumerate(loads):
             for n, b in g:
                 L[i, names[n]] = b
-        ref = int(np.argmax(A.mean(axis=1)))
-        scale = math.exp(0.5 * (tparts["cost"].s2 + float(L[ref] @ L[ref])))
-        others = [i for i in range(len(loads)) if i != ref]
-        if not others:
-            return scale * np.divide(1.0, A[ref], out=np.zeros_like(A[ref]), where=A[ref] > 0)
-        D = L[others] - L[ref]
-        w, V = np.linalg.eigh(D @ D.T)
-        keep = w > 1e-12 * max(float(w.max()), 1e-300)
-        pts, wts = _rule(int(keep.sum()))
-        axes = (V[:, keep] * np.sqrt(w[keep]))[:, ::-1]  # the largest axis first
-        mu = -(D @ L[ref])
-        out = np.zeros(A.shape[1])
-        for i in range(0, len(wts), _CHUNK):
-            S = A[ref][None, :] + np.exp(mu[None, :] + pts[i:i + _CHUNK] @ axes.T) @ A[others]
-            out += wts[i:i + _CHUNK] @ np.divide(1.0, S, out=np.zeros_like(S), where=S > 0)
-        return scale * out
+        return _ratio_mean(np.stack([groups[g] for g in loads]), np.stack([tokens[g] for g in loads]), L)
 
     def _predict(self, task: Task, plan: dict, tparts: dict, rule: AcceptanceRule | None,
                  rescue_usd: float | None) -> tuple[Prediction, dict]:
@@ -731,11 +759,11 @@ class FitState:
         cfg: Configuration = plan["config"]
         heads = self.heads
         cost_eta = {k: self._eta(heads["cost"], tparts["cost"], r)[1] for k, r in plan["cost"].items()}
-        tok_eta = {k: self._eta(heads["tokens"], tparts["tokens"], r)[1] for k, r in plan["cost"].items()}
+        rate_eta = {k: self._eta(heads["rate"], tparts["rate"], r)[1] for k, r in plan["cost"].items()}
         gate_eta = {k: self._eta(heads["gate"], tparts["gate"], r)[1] for k, r in plan["gate"].items()}
         rng = np.random.default_rng(self.sim_seed)
-        rd: RunDraws = compose(st, cost_eta, tok_eta, gate_eta, sigma_usd=heads["cost"].sigma,
-                               sigma_tokens=heads["tokens"].sigma, rng=rng)
+        rd: RunDraws = compose(st, cost_eta, rate_eta, gate_eta, sigma_usd=heads["cost"].sigma,
+                               sigma_rate=heads["rate"].sigma, floors=plan["floors"], rng=rng)
         _, s_eta = self._eta(heads["success"], tparts["success"], plan["run"])
         g = expit(s_eta)
         s_known, s_s2 = self._known(heads["success"], tparts["success"], plan["run"])
@@ -758,11 +786,10 @@ class FitState:
 
         m_usd, m_tok = per_draw(mr.exp_usd), per_draw(mr.exp_tokens)
         # The ell.tokens mean is the expectation of what its draws hold, the rescue priced at
-        # the draw's own tokens per dollar. Given the gates, the cost and tokens heads' unseen
-        # effects are independent, so E[T / C] = E[T] E[1 / C]: `mr` holds E[T], and `_inv_cost`
-        # integrates 1 / C over every unseen cost effect. The gates' unseen task effect stays under
-        # Gauss-Hermite. Without a rescue the ratio does not enter.
-        m_per_usd = per_draw(mr.exp_tokens * self._inv_cost(plan, tparts, mr)) if rescue > 0 else 0.0
+        # the draw's own tokens per dollar, E[T / C]: `_tokens_per_usd` integrates it over every
+        # unseen cost and rate effect. The gates' unseen task effect stays under Gauss-Hermite.
+        # Without a rescue the ratio does not enter.
+        m_per_usd = per_draw(self._tokens_per_usd(plan, tparts, mr)) if rescue > 0 else 0.0
         iv = Intervals()
         handles = {}
         for piece, pd in rd.pieces.items():
@@ -869,15 +896,22 @@ class FitState:
         return out
 
     def node_summary(self, level: str | None = None, head: str | None = None) -> list[NodeSummary]:
-        """Every fitted node's effect: its own deviation plus its ancestors' (the node's belief)."""
+        """Every fitted node's effect: its own deviation plus its ancestors' (the node's belief).
+
+        From 0.2.8 the tokens entries are derived, in the rate head's place: a node's tokens multiplier is its
+        cost multiplier over its rate multiplier on the same draws (log T = log U - log R), with the rate head's
+        support. It is the effect before the floor: a prediction holds each draw's rate at or above the model's
+        cache-read rate, so where that binds, the predicted tokens move less than the multiplier says."""
         parents = {n["id"]: n.get("parent") for n in self.design.get("nodes") or []}
         support = self.design.get("support") or {}
         wanted = set(LEVEL_ALIASES.get(level, (level,))) if level else None
         out: list[NodeSummary] = []
         for name, hs in self.heads.items():
-            if (head and name != head) or not hs.fitted or not hs.nodes:
+            shown = "tokens" if name == "rate" else name
+            if (head and shown != head) or not hs.fitted or not hs.nodes:
                 continue
             draws = hs.draws
+            cost = self.heads["cost"] if name == "rate" else None
             hsup = support.get(name) or {}
             for j, node in enumerate(hs.nodes):
                 lvl = display_level(node)
@@ -894,13 +928,27 @@ class FitState:
                     if k is not None:
                         chain.append(k)
                     cur = parents.get(cur)
-                effect, display = self._effect(hs, draws[chain].sum(axis=0))
+                eff = draws[chain].sum(axis=0)
+                if cost is not None:  # tokens: the cost chain's draws less the rate chain's
+                    eff = self._chain(cost, node, parents) - eff
+                effect, display = self._effect(hs, eff)
                 n_runs, mix = hsup.get(node) or [0, {}]
-                out.append(NodeSummary(level=lvl, key=node_key(node), head=name, effect=effect, display=display,
+                out.append(NodeSummary(level=lvl, key=node_key(node), head=shown, effect=effect, display=display,
                                        support=int(n_runs), parent=parents.get(node),
                                        source_mix={str(k): int(v) for k, v in (mix or {}).items()}))
         return out
 
+    @staticmethod
+    def _chain(hs: HeadState, node: str, parents: dict) -> np.ndarray:
+        """The draws of a node's effect in one head: its own and its ancestors' that the head has."""
+        idx, cur = [], node
+        while cur:
+            k = hs.index.get(cur)
+            if k is not None:
+                idx.append(k)
+            cur = parents.get(cur)
+        return hs.draws[idx].sum(axis=0) if idx else np.zeros(N_DRAWS)
+
     def _effect(self, hs: HeadState, eff: np.ndarray) -> tuple[Interval, Interval]:
         """cost: multiplier (x1.4); success and gate: log-odds shift, shown in pp at the baseline;
         score: shift on the modelled scale, shown in raw units (log: ratio; fraction: pp)."""

loopmath/ingest/base.py

@@ -58,6 +58,7 @@ MODEL_ALIASES = {
     "gpt-5.4": "gpt-5.4",
     "gpt-6-astra": "gpt-6-astra",
     "gpt-6-sol": "gpt-6-sol",
+    "gpt-6.1-sol": "gpt-6.1-sol",
     "gpt-6-luna": "gpt-6-luna",
 }
 

loopmath/prices.toml

@@ -142,7 +142,10 @@ output = 0.00
 source = "OpenCode 1.17.11 model catalog, opencode free route"
 
 # ---------------------------------------------------------------------------
-# Rows checked on the provider pages on 2026-09-23.
+# Rows checked on the provider pages on 2026-09-23; gpt-6.1-sol added and
+# gpt-6-luna checked again on 2026-10-12 (no newer luna is listed). as_of
+# stays the copied table's date: a row with no "checked" date takes it as
+# the date of its tariff, and those rows were not read again.
 # Each source names its page and the date it was read; the tariff record
 # written with every priced attempt takes its date from "checked YYYY-MM-DD".
 #
@@ -179,12 +182,19 @@ cache_write = 2.50
 output = 10.00
 source = "official list, https://developers.openai.com/api/docs/models/gpt-6-sol, checked 2026-09-23: standard tier, $2 input, $0.20 cached input, $2.50 cache write, $10 output; prompts over 272K input tokens bill more and are priced at this rate (a floor)"
 
+["gpt-6.1-sol"]
+input = 2.00
+cache_read = 0.10
+cache_write = 2.50
+output = 10.00
+source = "official list, https://developers.openai.com/api/docs/models/gpt-6.1-sol, checked 2026-10-12: standard tier, $2 input, $0.10 cached input, $2.50 cache write, $10 output; prompts over 272K input tokens bill more and are priced at this rate (a floor)"
+
 ["gpt-6-luna"]
 input = 0.10
 cache_read = 0.01
 cache_write = 0.125
 output = 0.50
-source = "official list, https://developers.openai.com/api/docs/models/gpt-6-luna, checked 2026-09-23: standard tier, $0.10 input, $0.01 cached input, $0.125 cache write, $0.50 output; prompts over 272K input tokens bill more and are priced at this rate (a floor)"
+source = "official list, https://developers.openai.com/api/docs/models/gpt-6-luna, checked 2026-10-12: standard tier, $0.10 input, $0.01 cached input, $0.125 cache write, $0.50 output; prompts over 272K input tokens bill more and are priced at this rate (a floor)"
 
 ["opus-4.8"]
 input = 5.00

loopmath/priors/benchmarks.py

@@ -11,7 +11,7 @@ results on it (0.2.3; spec 04 section 5).
 
 This module loads the file and checks it: every value is a published number
 with its own source line, success values are fractions, the reference
-model has a result, and only the 12 current models appear. A model with no
+model has a result, and only the 13 current models appear. A model with no
 result anywhere is listed by `missing_models`, never filled in.
 """
 
@@ -28,7 +28,7 @@ BENCHMARKS_TOML = Path(__file__).resolve().parent / "benchmarks.toml"
 # The current models in the packaged price table.
 MODELS = (
     "claude-opus-5-5", "claude-opus-5", "claude-fable-5-1", "claude-fable-5", "claude-sonnet-5", "haiku-4.5",
-    "gpt-6-astra", "gpt-6-sol", "gpt-6-luna", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
+    "gpt-6-astra", "gpt-6.1-sol", "gpt-6-sol", "gpt-6-luna", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
 )
 KINDS = ("success", "cost", "tokens")
 _DATE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
@@ -67,7 +67,7 @@ def check_benchmarks(data: dict) -> list[str]:
             problems.append(f"{where}: unknown benchmark")
             continue
         if r.get("model") not in MODELS:
-            problems.append(f"{where}: model is not one of the 12 current models (D50)")
+            problems.append(f"{where}: model is not one of the 13 current models (D50)")
         if r.get("effort") is not None and r["effort"] not in EFFORTS:
             problems.append(f"{where}: effort {r['effort']!r} is not one of {sorted(EFFORTS)}")
         value = r.get("value")
@@ -98,7 +98,7 @@ def check_benchmarks(data: dict) -> list[str]:
 
 
 def coverage(data: dict) -> dict[str, list[str]]:
-    """Model to the benchmark ids that have a result for it, for the 12 current models."""
+    """Model to the benchmark ids that have a result for it, for the 13 current models."""
     out: dict[str, list[str]] = {m: [] for m in MODELS}
     for r in data.get("result") or []:
         ids = out.get(r.get("model"))

loopmath/recommend/commands.py

@@ -40,8 +40,9 @@ FALLBACK_REVIEWER = ("codex", "gpt-6-astra", "xhigh")
 # The models offered when neither `--models` nor `models.allowed` is set (0.2.2): the current ones only. Any
 # other model is retired: its runs stay data for the fit and its workflow can be the reference line, but it is
 # never a pick, a choice or a candidate. First the fallback implementer, then the fallback reviewer, as
-# `models.allowed` order is read, so a store with no habits keeps the default usual it had.
-DEFAULT_MODELS = ("claude-opus-5-5", "gpt-6-astra", "gpt-6-sol", "gpt-6-luna", "claude-sonnet-5", "claude-fable-5-1")
+# `models.allowed` order is read, so a store with no habits keeps the default usual it had. gpt-6.1-sol is the
+# current sol (0.2.8); gpt-6-sol stays in the catalog, and `--models` can still offer it.
+DEFAULT_MODELS = ("claude-opus-5-5", "gpt-6-astra", "gpt-6.1-sol", "gpt-6-luna", "claude-sonnet-5", "claude-fable-5-1")
 REVIEW_ROLES = ("reviewer", "referee", "review", "select")
 # `--json --brief`: what an agent needs to show the choices and start one. The stored
 # recommendation and the full JSON keep everything; a key added to recommend/2 stays out unless listed.
@@ -601,9 +602,10 @@ def typical(rec: Recommendation | None, p) -> str:
 
 def line_numbers(p, *, first: bool = False, marks: tuple[str, ...] = (), rec: Recommendation | None = None,
                  lead_typical: bool = False) -> str:
-    """Chance, run cost with its median, expected rescue and `ell`, which the first line spells out; a
-    mean above its interval's upper end gets the tail note in its parentheses, after any `marks` such as
-    "uncertain". With `lead_typical` the run cost is the typical run with its range; the caller prints the mean."""
+    """Chance, run cost with its tokens, then its median, expected rescue and `ell`, which the first line spells
+    out; a mean above its interval's upper end gets the tail note in its parentheses, after any `marks` such as
+    "uncertain". The tokens are the mean run's, so they follow the mean cost; after the median they read as the
+    median run's. With `lead_typical` the run cost is the typical run with its range; the caller prints the mean."""
     ell = fmt_usd(p.ell.usd.mean)
     note = TAIL if heavy(p.ell.usd) else ""
     per = (f"expected cost per accepted result {ell}{paren('lower is better', *marks, note)}" if first
@@ -616,7 +618,7 @@ def line_numbers(p, *, first: bool = False, marks: tuple[str, ...] = (), rec: Re
     if lead_typical:
         return f"{chance}, typical run {typical_cost(p.cost)}, {rescue}{per}"
     return (f"{chance}, {fmt_usd(p.cost.usd.mean)} a run "
-            f"({(med + '; ') if med else ''}{fmt_tokens(p.cost.tokens.mean)} tokens"
+            f"({fmt_tokens(p.cost.tokens.mean)} tokens{('; ' + med) if med else ''}"
             f"{tail(p.cost.usd, p.cost.tokens)}), {rescue}{per}")
 
 

loopmath/skill/skills/loopmath-plan-task/SKILL.md

@@ -58,9 +58,9 @@ Then ask exactly one question: "Which one should I start? (1 to N, or describe a
 > 1. Recommended: plan_implement: opus-5-5/high, sonnet-5/high: 78% in one run (61 to 90%), 90% within 3 attempts, $1.20 a run (median $0.95), $1.73 per accepted result
 > 2. Pair: 1 plus plan_implement_review: sonnet-5/high x3: extra $0.80 now, judged blind; pays back after 4 similar tasks
 > 3. Your usual (reference): 71% in one run (52 to 86%), 85% within 3 attempts, $1.45 a run (median $1.10), $2.36 per accepted result
-> 4. Most likely to reach the target: best_of_n: gpt-6-sol/xhigh x3: 88% in one run (70 to 97%), 96% within 3 attempts, $4.10 a run (median $3.80), $4.90 per accepted result
+> 4. Most likely to reach the target: best_of_n: gpt-6.1-sol/xhigh x3: 88% in one run (70 to 97%), 96% within 3 attempts, $4.10 a run (median $3.80), $4.90 per accepted result
 > 5. Cheapest run: solo: sonnet-5/medium: 52% in one run (30 to 73%), 70% within 3 attempts, $0.35 a run, $2.40 per accepted result
-> Run cost is what the agents cost for one run; cost per accepted result adds the expected cost of fixing a miss by retrying with best_of_n: gpt-6-sol/xhigh x3, each extra attempt having half the chance of the one before, up to 3 attempts.
+> Run cost is what the agents cost for one run; cost per accepted result adds the expected cost of fixing a miss by retrying with best_of_n: gpt-6.1-sol/xhigh x3, each extra attempt having half the chance of the one before, up to 3 attempts.
 > Planning page: /Users/me/.loopmath/views/recommend-20260924-181502.html
 > Which one should I start? (1 to 5, or describe another workflow)
 

loopmath/views/assets/estimates.js

@@ -69,7 +69,7 @@
     var arrow = m.better === 'lower' ? ' Lower is better (↓).' : m.better === 'higher' ? ' Higher is better (↑).' : '';
     if (head.indexOf('score:') === 0 && k === 'multiplier') return 'How much a node multiplies the score ' + head.slice(6) + ' on one run: x1.00 is no change.' + arrow;
     if (head.indexOf('score:') === 0 && k === 'pp') return 'How a node shifts the score ' + head.slice(6) + ' on one run, in percentage points.' + arrow;
-    if (head === 'tokens') return 'How much a node multiplies tokens per round, relative to its parent: x1.00 is no change, below x1 is fewer.';
+    if (head === 'tokens') return 'How much a node multiplies tokens per round, relative to its parent: x1.00 is no change, below x1 is fewer. It is the cost multiplier over the price-per-token multiplier, before the floor: a prediction never prices a token below its model\'s cache-read rate, so where that floor binds, the predicted tokens move less than this.';
     if (k === 'multiplier') return 'How much a node multiplies dollars per round, relative to its parent: x1.00 is no change, below x1 is cheaper.';
     if (head === 'gate') return 'How a node shifts the chance that a gate passes on a round, in percentage points at the group\'s base rate.';
     if (k === 'pp') return 'How a node shifts the chance of an accepted result, in percentage points at the group\'s base rate.';

{loopmath-0.2.7.dist-info → loopmath-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmath
-Version: 0.2.7
+Version: 0.2.8
 Summary: Plan agent workflows, record how they went, and learn from your own Claude Code and Codex logs
 Author: QKV Labs
 License-Expression: MIT

{loopmath-0.2.7.dist-info → loopmath-0.2.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-loopmath/__init__.py,sha256=snnq8mT6QJRclNwqXkzZUY8Xpy8fs4W2KWZiKzmLdsM,244
+loopmath/__init__.py,sha256=qoxVgTJW5APTeuqbAUGn9fc40vF7vi_cOBSq0yI2vAY,244
 loopmath/__main__.py,sha256=X6nV3FjHmxDbIjccOYrBts_0KyJwOmDEPI5URzMO_-8,126
 loopmath/adapter_host.py,sha256=KBLHsP-LzrRDzOaDQMJRDq-NfCJeT5nY_CQAPLqyKQ4,10284
 loopmath/cli.py,sha256=6oJ8m3KkAv7-yTh-p7WmqCNjbs1moy1jBExVzk-Et54,23459
@@ -21,7 +21,7 @@ loopmath/output.py,sha256=8dm7eh37D0cKAUFSIlcLtbJ8Td1gxxj6vjy99pOGHqs,4584
 loopmath/pool.py,sha256=s3DfC2G2S6rK47PEyzSpIM1wYNQKnScpCtIallHhego,1953
 loopmath/price.py,sha256=Mr3yINrwwH9dZ2aKrv7BTsyQcukkU9fU3I4M1l1GR2A,24880
 loopmath/price_validation.py,sha256=7VY-vli5JFBh1FV2dRC241Akr6gLbJ7qos6fhuBr8_c,13246
-loopmath/prices.toml,sha256=dzFTWB0YRu0O7Hvgcaw-tn9tZIywoYYGT2Puwvj-jRI,10802
+loopmath/prices.toml,sha256=5bYkgpWzK0D6numXZM6y-Ok3EuKevDH-iWBnsElIu1c,11376
 loopmath/receipts.py,sha256=gW_c1ZSyrL0czo1ilFdpeyonkqFuzKYbeaUknbrFDvE,7034
 loopmath/research_defaults.py,sha256=tKbCtQGdj5E37qaIZeQ72MaX0eZOVSX31wNtOTxtr6E,248
 loopmath/research_paths.py,sha256=dTXGaD0X0AqvMAZ90FuZZV5Qdxwjlb25ZplDhRTc8T8,2342
@@ -62,18 +62,18 @@ loopmath/belief/__init__.py,sha256=Ny_4xJWWvvAyI8gkrQtBBO-9uKXGvNWFQZcyAkQ06BA,1
 loopmath/belief/block.py,sha256=GoZ269Vql8L6rB5-klT7cGlx42Rc4m9KsRO9ccU7E8g,7037
 loopmath/belief/check_pymc.py,sha256=9BLVla7HqRMjF_G4biLyxWY223XVAklJdy1PuCbUOIU,6007
 loopmath/belief/commands.py,sha256=AxRn2XLiNk_RTbqQpVl_CovpRyv5c00vH5QCbLfiOGc,10298
-loopmath/belief/compose.py,sha256=ABqkq8wXc-UUv9RSKlyKJKA2Fhg3USyxSG9xxxcME34,9730
-loopmath/belief/design.py,sha256=CIFpqhljD6sEoMzEIO7D_kLZTQJkuobEXaTPAHXgv-c,42452
-loopmath/belief/features.py,sha256=cVLrDeSs-s4PBbQ0lm2wkdZxUd5DVoh-yG2Lj1Pa1iA,11454
-loopmath/belief/fit.py,sha256=7RTW9UQc2e4CKXsXpptL6wr3qgTkrJjm4Fn79fY1eeQ,37283
+loopmath/belief/compose.py,sha256=MjwvQHh2YpnTKvlQNWguiPm-lcnqIiHaClOH1aK77M4,11841
+loopmath/belief/design.py,sha256=e5mcCqeDNA1wtDmXnYrZ9Bfc7vVM5WJc_NKXRYMjjwY,42727
+loopmath/belief/features.py,sha256=4nStB7E1a3cgAXdh7xXCCH4Ddf9T9vNi0AFnx5DP_LQ,11615
+loopmath/belief/fit.py,sha256=W7XxO9LVoxaS2eP0VInqEY1yt2gEEzDnq-9WY5McaXE,38957
 loopmath/belief/forest.py,sha256=efHhbNdSl1_KIpPK317AlrzOvE6Jx80UiOZfjABC0EQ,8658
 loopmath/belief/gaussian.py,sha256=YgN-SUOzSKj-dXndjPaaDMOw2oCx_NVj3hoGtn2B_IM,22090
-loopmath/belief/lookahead.py,sha256=NBGEIoqV5OPqs97mCji7wBT2gWi842EL1nzfCu8skGM,19297
+loopmath/belief/lookahead.py,sha256=u-Z9xZ-nI0I1qumxfdONhMwct1ub0n4MwrNJG_P10dI,19295
 loopmath/belief/outcome.py,sha256=c2bnM0LEFBL3IjiibDq6DnyIbBuSPzK1MY48T4X8z9Y,6744
-loopmath/belief/pricing.py,sha256=KXMi1cQ3FWVSxb_2sTGlPKTtv_Mp7Dal_Q8-263Jjeg,6936
+loopmath/belief/pricing.py,sha256=vTKf7iheX9zW9TjpbNOk9BhLhxN0BZNLoSZXD0eKo6k,7914
 loopmath/belief/priors.py,sha256=Fi1dImT2rNQJzJrFU4XmAKnhsEK8ay__VFRuMkEvO-E,8053
 loopmath/belief/rules.py,sha256=nEZFBiDIxwDdqcxkeMiiKNrJ4SGRtBirTkCvTViv8As,6352
-loopmath/belief/state.py,sha256=pO5gEFP6XtpHZiL7VUCy4fCUxS2ACyvifgrs-XlUZwQ,48992
+loopmath/belief/state.py,sha256=NjycTv40skGlcvBKnypCiQX3eDsBW_8gZWS6QrbFHgU,52020
 loopmath/builder/__init__.py,sha256=E9_JLObtnM_r2to6bqH13xV3LHN00zVIRH1nzJTCv7s,105
 loopmath/builder/cli.py,sha256=NPMkFE0vIOAsEMCtGVkvzdzmszrNd7uZ3CNX_E-zV9M,2429
 loopmath/builder/context.py,sha256=1NCKZSx9Fn64pSixnLJqV80fPDtoPusttnj5ZnjhDrU,18387
@@ -145,7 +145,7 @@ loopmath/graph/scan.py,sha256=-7dU9xVKWjHLdnK7LFjSIk2X0-jVUowdnFZhCc8sAnI,10413
 loopmath/graph/schema.py,sha256=qWb2FZnaGU5q0CcfNpStrKwAO0Hb_p3HnMCj8fLlO7Y,6601
 loopmath/graph/token_completeness.py,sha256=PWFJHbo5EZhC3vCwkLLRF-yi-hpGjP3Zw3ofoC-rvcw,916
 loopmath/ingest/__init__.py,sha256=4wLZg89gTwI9h8yXPfcrtgO_Z_AqDFt74_7Zxbrhjo0,19889
-loopmath/ingest/base.py,sha256=Q9hTuVbFFLwGT6kPSpi4tgZWs_aJD3-ubNe0O2y7NGQ,20029
+loopmath/ingest/base.py,sha256=TEj7OLysgbGvMHLxTLxDlF6i_C34_3PsTE8pK4JEl_o,20063
 loopmath/ingest/claude_code.py,sha256=IMdjzzuzTCNO6iL6fLl2zwSvzWQGwzgyqMjaisM7Mjo,24846
 loopmath/ingest/claude_code_support.py,sha256=BU3aSxTOvhpUlyPOSmBOcwnTfMP8cnnGlAwmuNFX8OU,2423
 loopmath/ingest/codex.py,sha256=oKJKol69ps83Y_0ZqjkbMP6qCQPD6zwbXW_D0nn6c-g,27262
@@ -183,7 +183,7 @@ loopmath/onboard/history.py,sha256=qQqidw7pg-XOSQir8bcImTfP3fdFcGt8VsnrpuRMX4A,2
 loopmath/onboard/label.py,sha256=nKlveJNggqxKcK3I60QQF8L0y0iEcm2d-LIP0Ca3n50,19571
 loopmath/onboard/usual.py,sha256=rEyg6WOCzEN8Y-UsHLh2br218qdca3IzRp1FVaA_qgw,3444
 loopmath/priors/__init__.py,sha256=vruMFu0UAW_IDoRquKw9skmaqfrOXXYGhtfW_wTxc90,5749
-loopmath/priors/benchmarks.py,sha256=el_D9DP3M0N4HCeBFK74EplyMsx2DC6M_ezDOO2-b9g,5745
+loopmath/priors/benchmarks.py,sha256=hqxOvDFS72A2tfTUpexFPogj7Y30b4CJvXNCQ3F9-rY,5760
 loopmath/priors/benchmarks.toml,sha256=geoPVCpSnhrgey2ynO7Kkn6picV0suBjhcOWUoCp_QE,54412
 loopmath/priors/build.py,sha256=bkT1JPcr-198jC9FZZiUWYY7M9uc-YG7S3VtJvA3PpU,16664
 loopmath/priors/commands.py,sha256=01HoZNVoH_6BVkhfusa2JEz4JuwPPOLqL_g2VGu0M20,5691
@@ -205,7 +205,7 @@ loopmath/priors/bundle/rq1.jsonl.gz,sha256=Ejk6cKab9aFYpjT9kdbek46T3m_lzjCUbtJGU
 loopmath/priors/bundle/sweep.jsonl.gz,sha256=0f6kxs-DdWt51FUec4zeYk5EAhD7OQjZ5gpQPIOG4Xg,135748
 loopmath/recommend/__init__.py,sha256=KsxeqH9dZFG2y9vV8JfKfcXtb-neWDshjQwdkRgIeB0,138
 loopmath/recommend/backlog.py,sha256=Y_GsWF5S4bR6V66HckotQtNr3IV6bpwbhzbQ0XjV1rQ,31613
-loopmath/recommend/commands.py,sha256=2LvieWZhM18BQhw5KaPryHVRXDElzuyv7O93qtoH5Og,38099
+loopmath/recommend/commands.py,sha256=CGbK7OgI6fggJEm0LPAxrMNHFYdCMZHo4GRbeWAe2_o,38340
 loopmath/recommend/curve.py,sha256=cxe2pR9-Ye5XciEUlKFlJpYKeo-FNokYaqJBuChTpsU,9831
 loopmath/recommend/engine.py,sha256=YjW-D8jVYOvKdL6DtvfOgmdEb6-Xkqacmw36Q1kJNqs,44058
 loopmath/recommend/gain.py,sha256=PPd6D3XKyPPwcE13X0Q3T82LoNEQF45KVBuabhAvKPw,7446
@@ -233,7 +233,7 @@ loopmath/skill/skills/reference.md,sha256=feqZIhyKCRDb7Cl46g73IqD_0D99aXy6frfg4V
 loopmath/skill/skills/loopmath/SKILL.md,sha256=MUb_5Nu_0HwuD_pKHiQgoopxG6YLV2gj99oXT6umuAA,2473
 loopmath/skill/skills/loopmath-import-runs/SKILL.md,sha256=A-mSL5-a31-umQCtpHgnclHD3V1_eSKGMV1SmrxTHdE,3131
 loopmath/skill/skills/loopmath-onboard/SKILL.md,sha256=hQDyFW5FBgw03p6pHl3CxJIiHrQ3edbZmSwcmZMSJ0s,4814
-loopmath/skill/skills/loopmath-plan-task/SKILL.md,sha256=uQSUfVJxDu7j8qmt58I3Spx_zUbj-Or9HW1A7nKXfJI,10687
+loopmath/skill/skills/loopmath-plan-task/SKILL.md,sha256=TE6UcVtRUGy3gkCKZLl05i472IGKeT14-gVb6gA_dzc,10691
 loopmath/skill/skills/loopmath-record-run/SKILL.md,sha256=rp6rI0fkeE5Fcng1dGKdae6q0K6R_kK8aLbHpDMWazk,6723
 loopmath/skill/skills/loopmath-update-fit/SKILL.md,sha256=JEO8sEm2GsBZ7IoJNOkSdAshTtBofFa0Rfy34P-0aN4,2648
 loopmath/store/__init__.py,sha256=vCGuqOSRKmKoT4eLbjEl8kxJRwdHWqxouGTp6gqPLFE,708
@@ -264,7 +264,7 @@ loopmath/views/assets/builder.html,sha256=I9tWu6V_iN2iT9rrDcZvy_LdTHHifPIdvmfD-9
 loopmath/views/assets/builder.js,sha256=YFY9t9ZxodZxV4srXIv4xUWFNE7rYdBGoWomRbFZUdc,100685
 loopmath/views/assets/common.js,sha256=DUQsTagXBdsMd17iAhyDAMAUw1Qu8xzNmqqLhJPxczA,15314
 loopmath/views/assets/estimates.css,sha256=6svx7lENnkXf-38emFJUxONGmXXbU77lnWupJFWLuF0,4321
-loopmath/views/assets/estimates.js,sha256=X_DQcISewPLmwc2GHOr73DHOBm4N9qumvUyVjILEOgQ,51889
+loopmath/views/assets/estimates.js,sha256=ZgR_gqQOg9GPsGBtS42XXqnirUF14YDfYNMfPYBjQQU,52109
 loopmath/views/assets/graph.css,sha256=6-jiJ1T5aiiMVeEse7Oz-w72r-zqb2tX6UeApmdmp4c,1799
 loopmath/views/assets/graph.js,sha256=mv-yCXwoMYcRhDFzlKFZPaiTKjbv6uTNvt2UyU0bzYk,36947
 loopmath/views/assets/plans.css,sha256=mRjg4FEiB2a_cGcMZwyFEqvwNHNR24UJ26nkPbVp0nk,2986
@@ -291,12 +291,12 @@ loopmath/workflows/catalog/plan_implement.toml,sha256=qxAs6G3JGOUuW6TnhiaUXzaFfy
 loopmath/workflows/catalog/plan_implement_review.toml,sha256=rRtiactglcJAynFWbrjnI-Ftbl3qe971ov9HJ3Vr7uU,862
 loopmath/workflows/catalog/solo.toml,sha256=aJWBEEfS4DNCLqznDI3yp-7s1ZXx_rdqsEIPX7n0-nM,373
 loopmath/workflows/catalog/swarm.toml,sha256=1hbQR41nl7VS_XN1z2fmwLCNw6kn2syowpwwauFUL3o,850
-loopmath-0.2.7.data/data/spec/ocp-v0.2.schema.json,sha256=T4P5gg6H2dW-28MRbg9fSNct_ejXezI69-SaKR9WogU,31855
-loopmath-0.2.7.data/data/spec/ocp-v0.schema.json,sha256=tOGqmvAjh0Ap09zV3QLQp3PovQB8inpVNgxSnrPS354,15279
-loopmath-0.2.7.data/data/spec/ocp_conformance.py,sha256=VzRGKvC6f-64U72xrDOSJEeYa92Bpj3tEf5x0uJXqhk,893
-loopmath-0.2.7.dist-info/licenses/LICENSE,sha256=QMvrQqRQRR-OjtyK0CiOxBV8NgWwr_QacIeFUWXeI5o,1065
-loopmath-0.2.7.dist-info/METADATA,sha256=4QjbQ7jzkm6jOwPBvyl7WJ2Bp0oUIPUmGkHcQ5JJim0,21861
-loopmath-0.2.7.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-loopmath-0.2.7.dist-info/entry_points.txt,sha256=WQwYqfGAwvoQ_vu6_lwQpq3V8xbK3i9SyNKPDdQ1VmQ,72
-loopmath-0.2.7.dist-info/top_level.txt,sha256=SH9Y0Z7thA0zx1PAgHAwc1vOJaS6o3yS5HazS-LzXOg,9
-loopmath-0.2.7.dist-info/RECORD,,
+loopmath-0.2.8.data/data/spec/ocp-v0.2.schema.json,sha256=T4P5gg6H2dW-28MRbg9fSNct_ejXezI69-SaKR9WogU,31855
+loopmath-0.2.8.data/data/spec/ocp-v0.schema.json,sha256=tOGqmvAjh0Ap09zV3QLQp3PovQB8inpVNgxSnrPS354,15279
+loopmath-0.2.8.data/data/spec/ocp_conformance.py,sha256=VzRGKvC6f-64U72xrDOSJEeYa92Bpj3tEf5x0uJXqhk,893
+loopmath-0.2.8.dist-info/licenses/LICENSE,sha256=QMvrQqRQRR-OjtyK0CiOxBV8NgWwr_QacIeFUWXeI5o,1065
+loopmath-0.2.8.dist-info/METADATA,sha256=UfU5gNcFnHHgA6EeaV1A-xRdQ_b6j3HcI-i7F4_C8G8,21861
+loopmath-0.2.8.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+loopmath-0.2.8.dist-info/entry_points.txt,sha256=WQwYqfGAwvoQ_vu6_lwQpq3V8xbK3i9SyNKPDdQ1VmQ,72
+loopmath-0.2.8.dist-info/top_level.txt,sha256=SH9Y0Z7thA0zx1PAgHAwc1vOJaS6o3yS5HazS-LzXOg,9
+loopmath-0.2.8.dist-info/RECORD,,