loopmath 0.2.1__tar.gz → 0.2.3__tar.gz

{loopmath-0.2.1 → loopmath-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmath
-Version: 0.2.1
+Version: 0.2.3
 Summary: Plan agent workflows, record how they went, and learn from your own Claude Code and Codex logs
 Author: QKV Labs
 License-Expression: MIT
@@ -103,6 +103,8 @@ Reading the history uses up to 8 worker processes (one per CPU, at most 8). Set
 
 loopmath ships with a prior built from our own sweeps and experiments, so `recommend` gives an answer before you have any history. Your own runs then move it.
 
+The prior ships inside the package: our runs, in the shared form (no titles, paths, commands or free text), and the published benchmark results. They are the same files we fit with, and each release updates them. `onboard` and the results page say in one line which prior they start from, and `loopmath prior show` lists it source by source.
+
 ## The loop
 
 The plan and record skills take an agent through the loop in three commands:

{loopmath-0.2.1 → loopmath-0.2.3}/README.md

@@ -65,6 +65,8 @@ Reading the history uses up to 8 worker processes (one per CPU, at most 8). Set
 
 loopmath ships with a prior built from our own sweeps and experiments, so `recommend` gives an answer before you have any history. Your own runs then move it.
 
+The prior ships inside the package: our runs, in the shared form (no titles, paths, commands or free text), and the published benchmark results. They are the same files we fit with, and each release updates them. `onboard` and the results page say in one line which prior they start from, and `loopmath prior show` lists it source by source.
+
 ## The loop
 
 The plan and record skills take an agent through the loop in three commands:

{loopmath-0.2.1 → loopmath-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "loopmath"
-version = "0.2.1"
+version = "0.2.3"
 description = "Plan agent workflows, record how they went, and learn from your own Claude Code and Codex logs"
 readme = "README.md"
 license = "MIT"

{loopmath-0.2.1 → loopmath-0.2.3}/src/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.1"
+__version__ = "0.2.3"

{loopmath-0.2.1 → loopmath-0.2.3}/src/loopmath/belief/design.py

@@ -13,7 +13,7 @@ A term is `(node_id, parent_id, value)`. Rows:
 from __future__ import annotations
 
 import math
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 from dataclasses import dataclass, field
 from datetime import datetime
 from functools import lru_cache
@@ -25,6 +25,7 @@ from ..types import (
     Workflow,
 )
 from .forest import canonical_model_id, canonical_role, model_path
+from .pricing import price_term
 
 Term = tuple[str, "str | None", float]
 
@@ -324,12 +325,15 @@ def _effort_scaled(terms: tuple[Term, ...], weight: float) -> tuple[Term, ...]:
 
 
 def cost_rest(st: Structure, piece: str, k: int, setting: Setting | None = None, *,
-              source: str | None = None, effort: float = 1.0) -> tuple[Term, ...]:
+              source: str | None = None, effort: float = 1.0,
+              prices: Mapping[str, float] | None = None) -> tuple[Term, ...]:
     """Cost and tokens rows without the task part: setting, role, topology, position, round, control,
     and with a `source` the position x source node `psrc:<shape>#<pos>|<source>` and the family x source
     node `fsrc:<family>|<source>` (spec 04 section 1). `effort` is the value of the terms a timebox caps, the
     effort and shape (topology, position) terms (`effort_weight`: below 1 under a timebox); the role, psrc and
-    fsrc terms stay at 1."""
+    fsrc terms stay at 1. `prices` is a fit's price offsets (`FitState.price_offsets`, spec 04 section 2): the
+    model's `price:offset` term goes last. The cost head has that node and the tokens head does not, so a
+    prediction's shared row prices only its cost."""
     s = setting or st.settings[piece]
     h, m, e = _s(s)
     shape = st.shape or st.workflow_id
@@ -343,7 +347,8 @@ def cost_rest(st: Structure, piece: str, k: int, setting: Setting | None = None,
         fam = model_path(m)[1]
         terms += ((f"psrc:{position}|{source}", f"position:{position}", 1.0),
                   (f"fsrc:{fam}|{source}", f"family:{fam}", 1.0))
-    return terms + tuple(round_terms(k)) + tuple(_control_terms(st.k_max, st.widths[piece]))
+    return (terms + tuple(round_terms(k)) + tuple(_control_terms(st.k_max, st.widths[piece]))
+            + price_term(prices, m))
 
 
 def gate_rest(st: Structure, gate: GateInfo, k: int) -> tuple[Term, ...]:
@@ -421,6 +426,7 @@ class AttemptObs:
     weight: float
     setting: Setting
     repriced: bool = True  # False: the recorded dollars, not the current tariff
+    streams: tuple[float, ...] = ()  # input, cache read, cache write, output tokens (pricing.STREAMS order)
 
 
 @dataclass
@@ -458,8 +464,12 @@ def source_label(doc: dict) -> str:
     ext = run.get("ext") or {}
     share = ext.get("dev.loopmath.share")
     if isinstance(share, dict):
-        org = share.get("org") or share.get("org_hash") or (run.get("task") or {}).get("org") or "shared"
-        return f"shared:{org}"
+        # the importer writes `source` and `task.org` as `shared:<org_hash>` already: never prefix twice. With no
+        # org at all the source is `shared`, the name `fit --without shared` takes (0.2.3, 22X review N1)
+        org = (share.get("source") or share.get("org") or share.get("org_hash") or (run.get("task") or {}).get("org")
+               or "")
+        name = str(org).removeprefix("shared:")
+        return f"shared:{name}" if name and name != "shared" else "shared"
     src = (run.get("task") or {}).get("source")
     kind = src.get("kind") if isinstance(src, dict) else src
     kind = str(kind or "").strip().lower()
@@ -761,7 +771,9 @@ def parse_run(doc: dict, *, now: datetime | None = None, rule: AcceptanceRule |
         if weight <= 0 or ((usd is None or usd <= 0) and not tokens):
             dropped["attempt without usable cost"] = dropped.get("attempt without usable cost", 0) + 1
             continue
-        attempts.append(AttemptObs(piece, k, usd if usd and usd > 0 else None, tokens, weight, setting, repriced))
+        streams = tuple(_ocp_fields(cost)[name] for name in _OCP_TOKEN_FIELDS)
+        attempts.append(AttemptObs(piece, k, usd if usd and usd > 0 else None, tokens, weight, setting, repriced,
+                                   streams))
 
     gates = _gate_observations(doc, st, by_piece_round)
     use_rule = rule or rule_from_doc(doc)

{loopmath-0.2.1 → loopmath-0.2.3}/src/loopmath/belief/fit.py

@@ -36,6 +36,7 @@ from .design import (DESIGN_VERSION, Term, Unusable, cost_row, gate_row, parse_r
 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 .gaussian import N_DRAWS, Factors, GaussianHead, HeadFit, LogisticHead, Prior
 from .state import SCORE_CLAMP, inverse_transform, transform  # noqa: F401  (re-exported)
 
@@ -163,6 +164,7 @@ class HeadRows:
     sources: list[str] = field(default_factory=list)
     types: list[str] = field(default_factory=list)
     not_repriced: int = 0  # cost rows on recorded dollars, not the current tariff
+    prices: dict = field(default_factory=dict)  # cost head: the fit's price offsets (pricing.fit_offsets)
 
     def add(self, terms, y, w, run, source, ttype):
         self.rows.append(terms)
@@ -213,6 +215,8 @@ def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tup
     stored: set[str] = set()  # run ids of the user's store, whose copy wins
     overlap: Counter = Counter()
     labels: Counter = Counter()
+    model_runs: dict[str, set[str]] = defaultdict(set)  # the price offset's inputs (spec 04 section 2)
+    model_streams: dict[str, list[float]] = defaultdict(lambda: [0.0] * len(STREAMS))
     for item in docs:
         origin, doc = item if isinstance(item, tuple) else (None, item)
         if origin is not None and _excluded(origin, without):
@@ -258,6 +262,10 @@ def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tup
             if a.usd:
                 heads["cost"].add(terms, math.log(a.usd), a.weight, pr.run_id, pr.source, ttype)
                 heads["cost"].not_repriced += not a.repriced
+                model_runs[a.setting.model].add(pr.run_id)
+                acc = model_streams[a.setting.model]
+                for i, v in enumerate(a.streams):
+                    acc[i] += v
             if a.tokens:
                 heads["tokens"].add(terms, math.log(a.tokens), a.weight, pr.run_id, pr.source, ttype)
         for gi, k, passed in pr.gates:
@@ -289,10 +297,34 @@ def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tup
     coding = tally.horizon_coding()  # the horizon terms need every run's horizon first (spec 04 section 1)
     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)
     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)
 
 
+def add_prices(hr: HeadRows, runs: dict[str, int], streams: dict[str, list[float]]) -> None:
+    """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"]
+    if not offsets:
+        return
+    rows = []
+    for row in hr.rows:
+        model = next((n[len("model:"):] for n, _, _ in row if n.startswith("model:")), None)
+        term = price_term(offsets, model) if model else ()
+        rows.append(row + list(term) if term else row)
+    hr.rows = rows
+
+
+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."""
+    if not hr.prices.get("models"):
+        return []
+    return [prior_data.FactorSpec("cost", [(PRICE_NODE, None, 1.0)], 1.0, PRICE_PRIOR_SD ** 2,
+                                  f"{PRICE_NODE} held at 1, prior N(1, {PRICE_PRIOR_SD}^2)")]
+
+
 # ---------------------------------------------------------------- matrices and priors
 
 def build_matrix(rows: list[list[Term]], forest: Forest, extra_nodes: Iterable[tuple[str, str | None]] = ()):
@@ -494,7 +526,8 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
     with fit_lock(home, wait_s):
         remove_partials(home)
         config = _read_config(home)
-        weight = float(config.get("benchmark_prior_weight", prior_data.BENCHMARK_PRIOR_WEIGHT))
+        raw_weight = config.get("benchmark_prior_weight")  # unset: each benchmark's own weight (spec 04 section 5)
+        weight = None if raw_weight is None else float(raw_weight)
         try:
             features, features_error = FeatureSet.from_config(config.get("features")), None
         except FeatureConfigError as exc:  # a hand-edited config.toml: fit with the built-ins, say why
@@ -518,9 +551,10 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
             raise UnknownSource(unknown_source_message(unknown, known))
         if not any(hr.rows for hr in heads_rows.values()):
             raise NothingToFit(_nothing_to_fit(no_prior, without, dropped))
-        specs = []
+        specs, bench_weights = [], {}
         if not no_prior and "benchmark" not in without:
             specs = prior_data.benchmark_factors(benchmarks, weight=weight)
+            bench_weights = prior_data.benchmark_weights(benchmarks, weight=weight)
         seed_key = input_key(heads_rows, specs, {"no_prior": no_prior, "without": sorted(without), "eb": eb,
                                                   "benchmark_prior_weight": weight})
         forest = Forest()
@@ -532,6 +566,8 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
             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 += price_spec(hr)
             fitted[name] = fit_head(hr, forest, head_specs, eb=eb)
         fit_id = new_fit_id(fits, now)
         partial = fits / f"{fit_id}.partial"
@@ -570,7 +606,7 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
             "seed_key": seed_key, "timebox_effort": design_rows.TIMEBOX_EFFORT_COST,
             "timebox_terms": list(design_rows.TIMEBOX_LEVELS),
             "options": {"no_prior": no_prior, "without": list(without), "full": full, "eb": eb,
-                        "benchmark_prior_weight": weight},
+                        "benchmark_prior_weight": weight, "benchmark_weights": bench_weights},
             "runs_by_source": runs_by_source,
             "n_runs": {"prior": sum(v for k, v in runs_by_source.items() if k != "user"),
                        "user": runs_by_source.get("user", 0)},
@@ -592,6 +628,7 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
             "design_version": DESIGN_VERSION,
             "features": {**tally.report, **({"error": features_error} if features_error else {})},
             "horizons": tally.horizon_report(),
+            "price_offsets": heads_rows["cost"].prices,
         }
         if full:
             meta["full"] = _full_check(fitted)

{loopmath-0.2.1 → loopmath-0.2.3}/src/loopmath/belief/forest.py

@@ -55,6 +55,7 @@ FIXED_SD: dict[str, tuple[float, float, float]] = {
     "round": (2.0, 2.0, 2.0),
     "control": (1.0, 1.0, 1.0),
     "horizon": (10.0, 10.0, 10.0),  # wide: the informative prior is a FactorSpec in fit() (spec 04 section 1)
+    "price": (10.0, 10.0, 10.0),  # wide: fit() holds `price:offset` at 1 by a FactorSpec (spec 04 section 2)
 }
 
 HYPER_SD = 0.7  # sd of the log-normal hyperprior on each phi, around the defaults above

loopmath-0.2.3/src/loopmath/belief/pricing.py

@@ -0,0 +1,142 @@
+"""The price offset on the cost head (spec 04 section 2, 0.2.2, lane 22C).
+
+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
+
+    o_m = s_m * log(P_m / R_m),   s_m = n0 / (n0 + n_m),
+
+and the node's coefficient is held at 1 by a tight prior, so the term is a fixed offset on the log cost scale,
+the same at fit and at prediction:
+
+- `P_m` is m's blended list price ($/Mtok, the current price table) under the token mix (the shares of input,
+  cache read, cache write and output tokens) of the cost rows of m's family in the fit.
+- `R_m` is the run-weighted geometric mean of the blended prices, under the same mix, of the family's models
+  with cost rows. A family with no cost rows anchors on its provider the same way (the provider's mix and
+  models). No anchor, or no price for m, gives no term.
+- `n_m` is m's runs with a cost row in the fit; `PRICE_OFFSET_RUNS` is n0: the price counts like n0 of the
+  model's own runs, and its share of the prediction shrinks as they accumulate.
+
+`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.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterable, Mapping
+
+from .forest import canonical_model_id, model_path
+
+PRICE_NODE = "price:offset"
+PRICE_LEVEL = "price"
+# n0: the list price counts like this many of the model's own runs (as one benchmark result counts like
+# BENCHMARK_PRIOR_WEIGHT = 5 runs). A heuristic, to tune when stores have new versions with a few runs.
+PRICE_OFFSET_RUNS = 5.0
+PRICE_PRIOR_SD = 1e-3  # the coefficient's prior N(1, sd^2): a fixed offset, not a learned elasticity
+STREAMS = ("input", "cache_read", "cache_write", "output")  # price table rate keys, in the order of `streams`
+
+
+def mix_of(totals: Iterable[float]) -> tuple[float, ...] | None:
+    """Token shares per stream (STREAMS order), or None without tokens."""
+    t = [max(0.0, float(x)) for x in totals]
+    s = sum(t)
+    return tuple(x / s for x in t) if s > 0 else None
+
+
+def blended(rate: Mapping[str, float] | None, mix: tuple[float, ...] | None) -> float | None:
+    """$/Mtok under `mix`, or None when the model has no rate, no mix, or a blended price of 0 (free)."""
+    if rate is None or mix is None:
+        return None
+    p = sum(share * float(rate.get(stream) or 0.0) for share, stream in zip(mix, STREAMS))
+    return p if p > 0 else None
+
+
+def shrink(runs: float, n0: float = PRICE_OFFSET_RUNS) -> float:
+    return n0 / (n0 + max(0.0, float(runs)))
+
+
+def _add(acc: dict[str, list[float]], key: str, values: Iterable[float]) -> None:
+    cur = acc.setdefault(key, [0.0] * len(STREAMS))
+    for i, v in enumerate(values):
+        cur[i] += float(v)
+
+
+def fit_offsets(runs: Mapping[str, int], streams: Mapping[str, Iterable[float]], table, *,
+                n0: float = PRICE_OFFSET_RUNS) -> dict:
+    """The fit's `price_offsets`: {n0, models: {model: offset}, detail, anchors}.
+
+    `runs`: model (canonical id) to its runs with a cost row; `streams`: model to its token totals over those
+    rows (STREAMS order); `table`: a price.PriceTable, or None (no offsets). Offsets of 0 are left out of
+    `models`; `detail` says for each priced model which anchor it used, or why it has none."""
+    out: dict = {"n0": n0, "models": {}, "detail": {}, "anchors": {}}
+    if table is None:
+        return out
+    fam_tok: dict[str, list[float]] = {}
+    prov_tok: dict[str, list[float]] = {}
+    fam_models: dict[str, dict[str, int]] = {}
+    prov_models: dict[str, dict[str, int]] = {}
+    for model, n in sorted(runs.items()):
+        if n <= 0:
+            continue
+        prov, fam, _ = model_path(model)
+        fam_models.setdefault(fam, {})[model] = int(n)
+        prov_models.setdefault(prov, {})[model] = int(n)
+        values = list(streams.get(model) or [0.0] * len(STREAMS))
+        _add(fam_tok, fam, values)
+        _add(prov_tok, prov, values)
+    candidates = set(runs) | {canonical_model_id(k) for k in table.rates}
+    anchors: dict[str, dict | None] = {}
+
+    def anchor(key: str, members: dict[str, int], tokens: list[float] | None) -> dict | None:
+        if key in anchors:
+            return anchors[key]
+        mix = mix_of(tokens or [])
+        priced = {m: (n, blended(table.rate(m), mix)) for m, n in members.items()}
+        priced = {m: (n, p) for m, (n, p) in priced.items() if p is not None}
+        found = None
+        if mix is not None and priced:
+            total = sum(n for n, _ in priced.values())
+            log_ref = sum(n * math.log(p) for n, p in priced.values()) / total
+            found = {"mix": mix, "log_ref": log_ref,
+                     "reference_usd_per_mtok": round(math.exp(log_ref), 6),
+                     "models": {m: n for m, (n, _) in sorted(priced.items())},
+                     "todo": sorted(m for m in priced if table.is_todo(m))}
+        anchors[key] = found
+        return found
+
+    for model in sorted(candidates):
+        prov, fam, _ = model_path(model)
+        a, key = None, None
+        if fam in fam_models:
+            key = f"family:{fam}"
+            a = anchor(key, fam_models[fam], fam_tok.get(fam))
+        if a is None and prov in prov_models and fam not in fam_models:
+            key = f"provider:{prov}"
+            a = anchor(key, prov_models[prov], prov_tok.get(prov))
+        if a is None:
+            out["detail"][model] = {"runs": int(runs.get(model, 0)), "note": "no anchor with runs and prices"}
+            continue
+        p = blended(table.rate(model), a["mix"])
+        if p is None:
+            out["detail"][model] = {"runs": int(runs.get(model, 0)), "anchor": key, "note": "no price"}
+            continue
+        n = int(runs.get(model, 0))
+        s = shrink(n, n0)
+        offset = s * (math.log(p) - a["log_ref"])
+        out["detail"][model] = {"runs": n, "anchor": key, "usd_per_mtok": round(p, 6), "shrink": round(s, 6),
+                                "log_ratio": round(math.log(p) - a["log_ref"], 6), "offset": round(offset, 6),
+                                **({"todo": True} if table.is_todo(model) else {})}
+        if offset != 0.0:
+            out["models"][model] = offset
+    out["anchors"] = {k: {**{kk: vv for kk, vv in v.items() if kk != "log_ref"}, "mix": [round(x, 6) for x in v["mix"]]}
+                      for k, v in sorted(anchors.items()) if v}
+    return out
+
+
+def price_term(offsets: Mapping[str, float] | None, model: str) -> tuple[tuple[str, None, float], ...]:
+    """The cost row's price term for `model` (a canonical id) under a fit's offsets: none for an offset of 0 or
+    a fit without offsets."""
+    if not offsets:
+        return ()
+    o = offsets.get(model)
+    return ((PRICE_NODE, None, float(o)),) if o else ()

{loopmath-0.2.1 → loopmath-0.2.3}/src/loopmath/belief/priors.py

@@ -10,8 +10,11 @@
   version nodes: success head, the logit gap to the benchmark's reference model with variance
   `1 / (w p (1 - p))`; cost head, the log cost ratio with variance `1 / w`; tokens head
   (`kind = "tokens"`, published total tokens for the evaluation), the log token ratio
-  with variance `1 / w`. `w` is config `benchmark_prior_weight` (default 5): one benchmark
-  result counts like about 5 runs.
+  with variance `1 / w`. `w` is one model's share of the benchmark's weight `w_b` (0.2.3,
+  lane 23K): the `weight` of its `[[benchmark]]` table (default 5, about 5 runs), shared by
+  the model's k results on that benchmark, so each gets `w_b / k` and a model with five
+  efforts pulls as hard in total as a model with one. Config `benchmark_prior_weight`, when
+  set, is one `w_b` for every benchmark; 0 turns the factors off.
 """
 
 from __future__ import annotations
@@ -91,8 +94,30 @@ def _model_terms(model: str, effort: str | None, sign: float) -> list[tuple[str,
     return terms
 
 
-def benchmark_factors(path: Path | None = None, *, weight: float = BENCHMARK_PRIOR_WEIGHT) -> list[FactorSpec]:
-    """Prior factors from `benchmarks.toml`. A missing file gives no factors."""
+def benchmark_weights(path: Path | None = None, *, weight: float | None = None) -> dict[str, float]:
+    """Each benchmark's weight `w_b`: `weight` for every benchmark when it is given (config
+    `benchmark_prior_weight`), else the benchmark's own `weight` field, else 5. Empty for a missing file."""
+    path = path or benchmark_path()
+    if not path.is_file():
+        return {}
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+    return {str(b["id"]): _weight_of(b, weight) for b in data.get("benchmark") or [] if b.get("id")}
+
+
+def _weight_of(bench: dict, weight: float | None) -> float:
+    if weight is not None:
+        return float(weight)
+    own = bench.get("weight")
+    return float(own) if isinstance(own, (int, float)) and not isinstance(own, bool) else BENCHMARK_PRIOR_WEIGHT
+
+
+def benchmark_factors(path: Path | None = None, *, weight: float | None = None) -> list[FactorSpec]:
+    """Prior factors from `benchmarks.toml`. A missing file gives no factors.
+
+    `weight` (config `benchmark_prior_weight`) overrides every benchmark's own weight; None reads
+    each benchmark's `weight`. A model's k results on one benchmark share its weight: each factor
+    has weight `w_b / k` (B1). A benchmark with weight 0 or less gives no factors.
+    """
     path = path or benchmark_path()
     if not path.is_file():
         return []
@@ -103,11 +128,15 @@ def benchmark_factors(path: Path | None = None, *, weight: float = BENCHMARK_PRI
     for bid, bench in benches.items():
         kind = str(bench.get("kind") or "success")
         ref = canonical_model_id(str(bench.get("reference") or ""))
+        w_b = _weight_of(bench, weight)
+        if w_b <= 0:
+            continue
         rows = [r for r in results if r["benchmark"] == bid]
         ref_rows = [r for r in rows if canonical_model_id(str(r["model"])) == ref]
         if not ref_rows:
             continue
         ref_value = float(ref_rows[0]["value"])
+        by_model: dict[str, list[tuple[str, list, float, dict]]] = {}  # model -> (head, terms, mean, row) per result
         for r in rows:
             model = canonical_model_id(str(r["model"]))
             if model == ref:
@@ -117,14 +146,24 @@ def benchmark_factors(path: Path | None = None, *, weight: float = BENCHMARK_PRI
             terms = _cancel(terms)
             if not terms:
                 continue
-            note = f"{bid}: {model} {value} against {ref} {ref_value} ({r.get('url', '')}, {r.get('date', '')})"
             if kind == "success":
                 p = min(max(value, 0.01), 0.99)
                 p_ref = min(max(ref_value, 0.01), 0.99)
                 gap = math.log(p / (1 - p)) - math.log(p_ref / (1 - p_ref))
-                out.append(FactorSpec("success", terms, gap, 1.0 / (weight * p * (1 - p)), note))
+                by_model.setdefault(model, []).append(("success", terms, gap, r))
             elif kind in ("cost", "tokens") and value > 0 and ref_value > 0:  # Tokens feed the tokens head only
-                out.append(FactorSpec(kind, terms, math.log(value / ref_value), 1.0 / weight, note))
+                by_model.setdefault(model, []).append((kind, terms, math.log(value / ref_value), r))
+        for model, items in by_model.items():
+            w = w_b / len(items)  # one budget per model and benchmark (B1)
+            share = f"weight {w_b:g} over {len(items)}" if len(items) > 1 else f"weight {w_b:g}"
+            for head, terms, mean, r in items:
+                note = (f"{bid}: {model} {float(r['value'])} against {ref} {ref_value} ({share}; "
+                        f"{r.get('url', '')}, {r.get('date', '')})")
+                if head == "success":
+                    p = min(max(float(r["value"]), 0.01), 0.99)
+                    out.append(FactorSpec("success", terms, mean, 1.0 / (w * p * (1 - p)), note))
+                else:
+                    out.append(FactorSpec(head, terms, mean, 1.0 / w, note))
     return out
 
 

{loopmath-0.2.1 → loopmath-0.2.3}/src/loopmath/belief/state.py

@@ -67,7 +67,7 @@ MIN_SCORE_SWITCH = 5  # spec 04 section 2: g = p_reach once the score head has 5
 BASE_HEADS = {"cost": ("gaussian", "cost"), "tokens": ("gaussian", "cost"), "gate": ("logistic", "logit"),
               "success": ("logistic", "logit")}
 TASK_CHAIN = ("task", "subtype", "repo", "type")
-FIXED_LEVELS = ("fixed", "round", "control")
+FIXED_LEVELS = ("fixed", "round", "control", "price")
 SCORE_CLAMP = (0.005, 0.995)
 _CACHE_LIMIT = 200_000
 MEAN_NODES = 12  # Gauss-Hermite nodes over an unseen normal effect
@@ -339,6 +339,8 @@ class FitState:
         self.sim_seed = _seed(self.seed_key, "simulate")
         # spec 04 section 1: the value of the timebox-capped terms (effort, shape) in a timeboxed task's cost rows
         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 {})
         if heads is None:
             heads = {}
             for name, hmeta in (self.meta.get("heads") or {}).items():
@@ -418,7 +420,8 @@ class FitState:
         for piece in st.pieces:
             rounds = st.k_max if st.piece_loop.get(piece) is not None else 1
             for k in range(1, rounds + 1):
-                cost[(piece, k)] = cost_rest(st, piece, k, source=PREDICT_SOURCE, effort=effort)
+                cost[(piece, k)] = cost_rest(st, piece, k, source=PREDICT_SOURCE, effort=effort,
+                                             prices=self.price_offsets)
         gate = {}
         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):
@@ -789,10 +792,13 @@ class FitState:
                                    gate_pass=res[hg] if hg is not None else None, rounds=res[hr],
                                    cost_per_round=Money(usd=res[hpr[0]], tokens=res[hpr[1]]) if hpr else None)
             for piece, (hu, ht, hg, hr, hpr) in handles.items()}
+        # The typical run (0.2.3): the median of the same simulated runs, one per draw, the 80% range is read from
+        run_usd = dataclasses.replace(res[h_run[1]], median=float(np.median(rd.sim_usd)))
+        run_tokens = dataclasses.replace(res[h_run[2]], median=float(np.median(rd.sim_tokens)))
         pred = Prediction(
             config=cfg.id,
             p_success=res[h_run[0]],
-            cost=Money(usd=res[h_run[1]], tokens=res[h_run[2]]),
+            cost=Money(usd=run_usd, tokens=run_tokens),
             ell=Money(usd=res[h_run[3]], tokens=res[h_run[4]]),
             rounds=res[h_run[5]],
             per_piece=per_piece,