loopmath 0.2.6__tar.gz → 0.2.8__tar.gz

{loopmath-0.2.6/src/loopmath.egg-info → loopmath-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmath
-Version: 0.2.6
+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
@@ -118,7 +118,7 @@ loopmath run start --rec REC --choice goal --base-commit SHA --json      # the h
 loopmath run record --run RUN --session UUID --verified tests=pass --json  # costs from the logs, the outcome, the receipt
 ```
 
-With `--run`, a session that started before the run counts from the run's start; a Codex session counts the usage it logged inside the window: each reading's increase at the reading's time, a reading on either edge included. Give `--since TS` and `--until TS` when the task's work began or ended at another time; `--since` before `run start` moves the run's start back. When no commit is found after the base commit, the record says where it looked; pass `--commit SHA`. `loopmath run sessions` lists the recent Claude Code and Codex sessions in this folder with their ids, for `--session ID`. Outside a Claude Code tool shell, `--session self` uses the one Claude Code session in this folder active in the last 10 minutes.
+With `--run`, a session that started before the run counts from the run's start; a Codex session counts the usage it logged inside the window: each reading's increase at the reading's time, a reading on either edge included. A sub-agent or a Codex child thread counts in full when it started inside the window, and not at all when it started before it. A Codex reading lower than the one before it (a compaction reset) counts from zero. A Codex session that cannot be cut to the window counts whole, with a note that says why: a reading with no time, or increases inside the window that add up to less than zero. Give `--since TS` and `--until TS` when the task's work began or ended at another time; `--since` before `run start` moves the run's start back. When no commit is found after the base commit, the record says where it looked; pass `--commit SHA`. `loopmath run sessions` lists the recent Claude Code and Codex sessions in this folder with their ids, for `--session ID`. Outside a Claude Code tool shell, `--session self` uses the one Claude Code session in this folder active in the last 10 minutes.
 
 The same loop step by step, for a tool of your own:
 
@@ -151,7 +151,7 @@ The usual workflow is the one most of your habit runs used: the runs onboard bro
 
 A pair runs the goal workflow and an exploration pick from the same base commit, in separate worktrees. `loopmath run start --rec REC --choice pair` starts both, on a new slate. To start them one at a time, save the recommendation (`recommend ... --json > rec.json`) and start each run from it, so they share one task: `loopmath run start --task-file rec.json --config CFG --source alternative --new-slate` for the goal, then the same with the pick's configuration, `--source exploration` and `--slate SLT`. A blinded referee then picks the better change, which you record with `loopmath outcome --slate SLT --prefer RUN --judge referee --blinded`. `loopmath runs --slate SLT` says which run the referee preferred.
 
-A run counts as a success when it is accepted under your rule. By default that means the task's tests pass. A rule can also be a score target: `loopmath recommend ... --target 'heldout_perf>=2400'` or `--target 'runtime_s<=200'` gives the expected score and the chance of reaching the target. Set standing rules and other options with `loopmath config set KEY VALUE` (`loopmath config get` lists every key, set or not, and `config set` refuses a key loopmath does not read), and the spending cap with `loopmath budget --usd X --period month`. Spend counts your runs and onboard's labelling calls; runs onboard brought in from your logs are shown apart and not counted. A run you record with `--source habit` counts.
+A run counts as a success when it is accepted under your rule. By default that means the task's tests pass. A run that `onboard` brought in from your logs, or that `run import` stored, with no tests verdict but a review or accepted verdict, is judged by the review rule instead: a success when its latest review or accepted verdict is accept, approve or pass. `loopmath runs` lists other finished runs such a verdict could settle, with the command that moves them to the review rule, `loopmath outcome --rule review RUN...`. `loopmath outcome --undo-rule RUN...` undoes that, restoring each run's rule as it was; naming that rule (`tests` when it had none) does too, unless the run's own rule was also named review. A review verdict on a reviewer's last attempt then counts twice: as the review gate's pass, and as the run's success. A rule can also be a score target: `loopmath recommend ... --target 'heldout_perf>=2400'` or `--target 'runtime_s<=200'` gives the expected score and the chance of reaching the target. Set standing rules and other options with `loopmath config set KEY VALUE` (`loopmath config get` lists every key, set or not, `config set` refuses a key loopmath does not read, and `loopmath config unset KEY` returns a key to its default), and the spending cap with `loopmath budget --usd X --period month`. Spend counts your runs and onboard's labelling calls; runs onboard brought in from your logs are shown apart and not counted. A run you record with `--source habit` counts.
 
 Runs recorded by another tool that writes OCP v0.3, such as an experiment runner, come in with `loopmath run import DIR --finish`: several files or a directory, with one refit at the end (`--no-fit` skips it). It says how many runs were new and how many were already in the store; importing finished runs into a store with no fit starts a fit. Runs in your store always count as yours, whatever source their documents name. `loopmath fit --without SOURCE` leaves out one shipped prior source, and `loopmath status` names the options of the current fit.
 

{loopmath-0.2.6 → loopmath-0.2.8}/README.md

@@ -80,7 +80,7 @@ loopmath run start --rec REC --choice goal --base-commit SHA --json      # the h
 loopmath run record --run RUN --session UUID --verified tests=pass --json  # costs from the logs, the outcome, the receipt
 ```
 
-With `--run`, a session that started before the run counts from the run's start; a Codex session counts the usage it logged inside the window: each reading's increase at the reading's time, a reading on either edge included. Give `--since TS` and `--until TS` when the task's work began or ended at another time; `--since` before `run start` moves the run's start back. When no commit is found after the base commit, the record says where it looked; pass `--commit SHA`. `loopmath run sessions` lists the recent Claude Code and Codex sessions in this folder with their ids, for `--session ID`. Outside a Claude Code tool shell, `--session self` uses the one Claude Code session in this folder active in the last 10 minutes.
+With `--run`, a session that started before the run counts from the run's start; a Codex session counts the usage it logged inside the window: each reading's increase at the reading's time, a reading on either edge included. A sub-agent or a Codex child thread counts in full when it started inside the window, and not at all when it started before it. A Codex reading lower than the one before it (a compaction reset) counts from zero. A Codex session that cannot be cut to the window counts whole, with a note that says why: a reading with no time, or increases inside the window that add up to less than zero. Give `--since TS` and `--until TS` when the task's work began or ended at another time; `--since` before `run start` moves the run's start back. When no commit is found after the base commit, the record says where it looked; pass `--commit SHA`. `loopmath run sessions` lists the recent Claude Code and Codex sessions in this folder with their ids, for `--session ID`. Outside a Claude Code tool shell, `--session self` uses the one Claude Code session in this folder active in the last 10 minutes.
 
 The same loop step by step, for a tool of your own:
 
@@ -113,7 +113,7 @@ The usual workflow is the one most of your habit runs used: the runs onboard bro
 
 A pair runs the goal workflow and an exploration pick from the same base commit, in separate worktrees. `loopmath run start --rec REC --choice pair` starts both, on a new slate. To start them one at a time, save the recommendation (`recommend ... --json > rec.json`) and start each run from it, so they share one task: `loopmath run start --task-file rec.json --config CFG --source alternative --new-slate` for the goal, then the same with the pick's configuration, `--source exploration` and `--slate SLT`. A blinded referee then picks the better change, which you record with `loopmath outcome --slate SLT --prefer RUN --judge referee --blinded`. `loopmath runs --slate SLT` says which run the referee preferred.
 
-A run counts as a success when it is accepted under your rule. By default that means the task's tests pass. A rule can also be a score target: `loopmath recommend ... --target 'heldout_perf>=2400'` or `--target 'runtime_s<=200'` gives the expected score and the chance of reaching the target. Set standing rules and other options with `loopmath config set KEY VALUE` (`loopmath config get` lists every key, set or not, and `config set` refuses a key loopmath does not read), and the spending cap with `loopmath budget --usd X --period month`. Spend counts your runs and onboard's labelling calls; runs onboard brought in from your logs are shown apart and not counted. A run you record with `--source habit` counts.
+A run counts as a success when it is accepted under your rule. By default that means the task's tests pass. A run that `onboard` brought in from your logs, or that `run import` stored, with no tests verdict but a review or accepted verdict, is judged by the review rule instead: a success when its latest review or accepted verdict is accept, approve or pass. `loopmath runs` lists other finished runs such a verdict could settle, with the command that moves them to the review rule, `loopmath outcome --rule review RUN...`. `loopmath outcome --undo-rule RUN...` undoes that, restoring each run's rule as it was; naming that rule (`tests` when it had none) does too, unless the run's own rule was also named review. A review verdict on a reviewer's last attempt then counts twice: as the review gate's pass, and as the run's success. A rule can also be a score target: `loopmath recommend ... --target 'heldout_perf>=2400'` or `--target 'runtime_s<=200'` gives the expected score and the chance of reaching the target. Set standing rules and other options with `loopmath config set KEY VALUE` (`loopmath config get` lists every key, set or not, `config set` refuses a key loopmath does not read, and `loopmath config unset KEY` returns a key to its default), and the spending cap with `loopmath budget --usd X --period month`. Spend counts your runs and onboard's labelling calls; runs onboard brought in from your logs are shown apart and not counted. A run you record with `--source habit` counts.
 
 Runs recorded by another tool that writes OCP v0.3, such as an experiment runner, come in with `loopmath run import DIR --finish`: several files or a directory, with one refit at the end (`--no-fit` skips it). It says how many runs were new and how many were already in the store; importing finished runs into a store with no fit starts a fit. Runs in your store always count as yours, whatever source their documents name. `loopmath fit --without SOURCE` leaves out one shipped prior source, and `loopmath status` names the options of the current fit.
 

{loopmath-0.2.6 → loopmath-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "loopmath"
-version = "0.2.6"
+version = "0.2.8"
 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.6 → loopmath-0.2.8}/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.6"
+__version__ = "0.2.8"

{loopmath-0.2.6 → loopmath-0.2.8}/src/loopmath/adapters/atrium.py

@@ -5,7 +5,7 @@ typed subagent-stop events whose subagent id may be empty. The stored facts are
 ``verified``, but runtime pane ids are not stable OCP task-node ids and the
 closed OCP edge vocabulary has no neutral message or runtime-correlation edge.
 This adapter therefore preserves them as typed metadata-only events under the
-documented ``dev.dagr.adapter.atrium`` extension and emits no core graph edge. It
+documented ``dev.loopmath.adapter.atrium`` extension and emits no core graph edge. It
 does not infer a spawn relation from a subagent-stop record or infer acceptance
 from segment closure, session end, or subagent stop.
 
@@ -35,7 +35,7 @@ from .registry import register
 
 _DEFAULT_ROOT = Path.home() / ".atrium"
 _STORE_NAMES = ("tasks.db", "timeline.db")
-_NAMESPACE = "dev.dagr.adapter.atrium"
+_NAMESPACE = "dev.loopmath.adapter.atrium"
 _TIMELINE_KINDS = ("agent-message", "session-end", "subagent-stop")
 _DIAGNOSTIC_REASONS = (
     "timeline_kind_unsupported",

{loopmath-0.2.6 → loopmath-0.2.8}/src/loopmath/adapters/bb.py

@@ -59,7 +59,7 @@ from .registry import register
 
 
 DEFAULT_STORE = Path.home() / ".bb" / "bb.db"
-EXT_NAMESPACE = "dev.dagr.adapter.bb"
+EXT_NAMESPACE = "dev.loopmath.adapter.bb"
 
 
 class _BbModule(_ModuleType):

{loopmath-0.2.6 → loopmath-0.2.8}/src/loopmath/adapters/omp_types.py

@@ -10,7 +10,7 @@ from typing import Any, Mapping
 from .base import Usage
 
 
-_EXT_NAMESPACE = "dev.dagr.adapter.omp"
+_EXT_NAMESPACE = "dev.loopmath.adapter.omp"
 _KNOWN_MESSAGE_ROLES = {"assistant", "system", "toolResult", "user"}
 _TOKEN_FIELDS = {
     "input": "input_tokens",

{loopmath-0.2.6 → loopmath-0.2.8}/src/loopmath/adapters/orca.py

@@ -39,7 +39,7 @@ from .registry import register
 
 
 _DEFAULT_STORE = Path.home() / "Library" / "Application Support" / "orca" / "orchestration.db"
-_NAMESPACE = "dev.dagr.adapter.orca"
+_NAMESPACE = "dev.loopmath.adapter.orca"
 _MESSAGE_TYPES = ("decision_gate", "escalation", "merge_ready", "worker_done")
 _DIAGNOSTIC_REASONS = (
     "start_options_missing",

{loopmath-0.2.6 → loopmath-0.2.8}/src/loopmath/adapters/otel_genai_types.py

@@ -13,7 +13,7 @@ from typing import Any, Iterable, Mapping
 from urllib.parse import quote
 
 
-EXT = "dev.dagr.adapter.otel-genai"
+EXT = "dev.loopmath.adapter.otel-genai"
 _TRACE_ID = re.compile(r"[0-9a-fA-F]{32}")
 _SPAN_ID = re.compile(r"[0-9a-fA-F]{16}")
 _RFC3339 = re.compile(

{loopmath-0.2.6 → loopmath-0.2.8}/src/loopmath/adapters/paseo.py

@@ -38,7 +38,7 @@ from .registry import register
 
 
 _DEFAULT_STORE = Path.home() / ".paseo" / "agents"
-_NAMESPACE = "dev.dagr.adapter.paseo"
+_NAMESPACE = "dev.loopmath.adapter.paseo"
 _TERMINAL = {"failed", "canceled", "settled_unverified"}
 _STATUS = {
     "working": "working",

{loopmath-0.2.6 → loopmath-0.2.8}/src/loopmath/belief/commands.py

@@ -74,6 +74,8 @@ def _summary(path: Path) -> dict:
         "full": meta.get("full"),
         "features": {k: v for k, v in (meta.get("features") or {}).items() if k != "declared"},
         "horizons": meta.get("horizons") or {},
+        **({"receipts_rescored": meta["receipts_rescored"]} if meta.get("receipts_rescored") else {}),
+        **({"notes": meta["notes"]} if meta.get("notes") else {}),
     }
 
 
@@ -85,6 +87,10 @@ def _print_summary(s: dict) -> None:
     f = s["fit"]
     n = f.get("n_runs") or {}
     print(f"fit {f['id']} written to {s['path']} in {s.get('seconds')} s; recommend and posterior now read it")
+    rescored = s.get("receipts_rescored")
+    if rescored:
+        print(f"{rescored} receipt{'' if rescored == 1 else 's'} scored before 0.2.7 re-scored first: the run's rule is "
+              "read as the fit reads it (a note on each run)")
     by_src = ", ".join(f"{k} {v}" for k, v in sorted(s["runs_by_source"].items(), key=lambda kv: -kv[1]))
     labels = ", ".join(f"{k} {v}" for k, v in sorted((s.get("user_labels") or {}).items(), key=lambda kv: -kv[1]))
     detail = "; ".join(x for x in (by_src, f"yours labelled {labels}" if labels else "") if x)
@@ -175,6 +181,9 @@ def fit(args: argparse.Namespace) -> int:
 
     from .fit import FitBusy, NothingToFit, UnknownSource, fit as run_fit
 
+    notes = _config_notes(home)
+    for note in notes:
+        print(f"note: {note}", file=sys.stderr)
     # --full: a failed compile makes pytensor print where it left the C code on stdout, which is for the result
     quiet = contextlib.redirect_stdout(sys.stderr) if full else contextlib.nullcontext()
     try:
@@ -192,8 +201,23 @@ def fit(args: argparse.Namespace) -> int:
             raise
         return _pymc_check_failed(home, exc)
     summary = _summary(path)
+    if notes:
+        summary["notes"] = notes + summary.get("notes", [])  # the fit printed its own on stderr
     if as_json:
         output.emit_json(SCHEMA, summary)
     else:
         _print_summary(summary)
     return output.EXIT_OK
+
+
+def _config_notes(home: Path) -> list[str]:
+    """A config.toml the fit cannot read leaves it on the built-in values; say so, as `runs` does (0.2.7)."""
+    from ..store.config import READ_ERRORS, Config, read_error
+
+    path = Path(home) / "config.toml"
+    try:
+        Config.load(path)
+    except READ_ERRORS as exc:
+        return [f"{read_error(path, exc)}; outcomes use the built-in q, and the fit the built-in features and "
+                "benchmark weights"]
+    return []

{loopmath-0.2.6 → loopmath-0.2.8}/src/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-0.2.6 → loopmath-0.2.8}/src/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)
@@ -720,6 +724,14 @@ def _check_name(a: dict, node: dict) -> str | None:
     return str(gate.get("rule") or node.get("id") or a.get("node") or a.get("harness") or "check")
 
 
+def run_evidence(doc: dict, rule: AcceptanceRule, *, now: datetime,
+                 q_by_tier: dict[str, float] | None = None) -> Evidence:
+    """The run's outcome as the fit reads it: `rules.evidence` under `rule` (None `q_by_tier`: the built-in q)."""
+    from . import rules
+
+    return rules.evidence(doc, rule, now=now, q_by_tier=q_by_tier)
+
+
 def parse_run(doc: dict, *, now: datetime | None = None, rule: AcceptanceRule | None = None,
               origin: str | None = None, q_by_tier: dict[str, float] | None = None) -> ParsedRun:
     """Everything the fit needs from one finished OCP v0.3 run document. Raises Unusable.
@@ -727,8 +739,6 @@ def parse_run(doc: dict, *, now: datetime | None = None, rule: AcceptanceRule |
     `origin` is where the fit found the document (`data_source`); None reads its label. `q_by_tier` is
     `outcome.q.<tier>` from config.toml, passed to `outcome_evidence` (None: the built-in q).
     """
-    from .outcome import outcome_evidence
-
     run = doc.get("run") or {}
     cfg = run.get("configuration")
     if not isinstance(cfg, dict):
@@ -786,8 +796,10 @@ def parse_run(doc: dict, *, now: datetime | None = None, rule: AcceptanceRule |
                                    streams))
 
     gates = _gate_observations(doc, st, by_piece_round)
-    use_rule = rule or rule_from_doc(doc)
-    evidence = outcome_evidence(doc, use_rule, now=now or datetime.now().astimezone(), q_by_tier=q_by_tier)
+    from .rules import resolve_rule
+
+    use_rule = rule or resolve_rule(doc)  # one resolver for every reader (0.2.7); raises on a malformed score
+    evidence = run_evidence(doc, use_rule, now=now or datetime.now().astimezone(), q_by_tier=q_by_tier)
     score_meta: dict[str, dict] = {}
     for s in run.get("signals") or []:
         if s.get("kind") == "score" and isinstance(s.get("value"), (int, float)) and not isinstance(s.get("value"), bool):

{loopmath-0.2.6 → loopmath-0.2.8}/src/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-0.2.6 → loopmath-0.2.8}/src/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):
@@ -146,7 +150,7 @@ def _read_config(home: Path) -> dict:
     path = Path(home) / "config.toml"
     try:
         return tomllib.loads(path.read_text(encoding="utf-8"))
-    except (OSError, tomllib.TOMLDecodeError):
+    except (OSError, ValueError):  # unreadable, not TOML, or not UTF-8: the built-in values (`fit` says so)
         return {}
 
 
@@ -165,6 +169,8 @@ class HeadRows:
     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)
+    # success head, with a configured q only: each row's w under the built-in q, which the seed hashes (0.2.7)
+    seed_w: list[float] = field(default_factory=list)
 
     def add(self, terms, y, w, run, source, ttype):
         self.rows.append(terms)
@@ -206,6 +212,7 @@ def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tup
     features = features or FeatureSet()
     tally = FeatureTally(features)
     heads = {name: HeadRows(name, *HEAD_KIND[name]) for name in HEAD_KIND}
+    configured_q = custom_q(q_by_tier) is not None
     score_raw: dict[str, list] = defaultdict(list)
     score_meta: dict[str, Counter] = defaultdict(Counter)
     score_info: dict[str, dict] = {}
@@ -270,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)
@@ -277,6 +287,8 @@ def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tup
         ev = pr.evidence
         if ev is not None and ev.z is not None:
             heads["success"].add(row, float(ev.z), float(ev.q), pr.run_id, pr.source, ttype)
+            if configured_q:  # z and the tier do not depend on q, so this read differs from `ev` in q only
+                heads["success"].seed_w.append(float(design_rows.run_evidence(doc, pr.rule, now=now).q))
         for name, value in (ev.scores if ev else {}).items():
             meta = pr.score_meta.get(name) or {}
             score_meta[name][(meta.get("scale") or "linear", meta.get("better") or "higher", meta.get("unit"))] += 1
@@ -300,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)
 
@@ -308,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 = []
@@ -320,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)")]
 
 
@@ -396,24 +416,41 @@ def _support(hr: HeadRows, X: sparse.csr_matrix, node_ids: list[str]) -> dict[st
     return out
 
 
+def custom_q(q_by_tier: dict[str, float] | None) -> dict[str, float] | None:
+    """`outcome.q.<tier>` for every tier when it differs from the built-in q anywhere, else None."""
+    from .outcome import TIER_Q
+
+    if not q_by_tier:
+        return None
+    merged = {tier: float(q_by_tier.get(tier, q)) for tier, q in TIER_Q.items()}
+    return merged if merged != TIER_Q else None
+
+
 def seed_for(fit_id: str, head: str) -> int:
     """A head's seed from the fit's `seed_key` (its fit id before 0.2.1)."""
     return int.from_bytes(hashlib.sha256(f"{fit_id}/{head}".encode()).digest()[:4], "little")
 
 
 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."""
+    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).
+
+    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())
-        for line in sorted(repr((t, y, w, r, src)) for t, y, w, r, src in zip(hr.rows, hr.y, hr.w, hr.runs, hr.sources)):
+        weights = hr.seed_w or hr.w
+        for line in sorted(repr((t, y, w, r, src)) for t, y, w, r, src in zip(hr.rows, hr.y, weights, hr.runs, hr.sources)):
             h.update(line.encode())
     return h.hexdigest()
 
@@ -513,12 +550,38 @@ def point_latest(fits: Path, fit_id: str) -> None:
     os.replace(tmp, fits / "latest")
 
 
+def _settle_receipts(home: Path) -> tuple[list[str], str | None]:
+    """Receipts `run finish` scored before 0.2.7 under a rule it read otherwise than the fit are re-scored before
+    every fit of the store, foreground or background (`store.finish.settle_rule_receipts`). A receipt that could
+    not be read, re-scored or written, or a run file that could not be written, is named in a note on stderr, and the
+    next fit does what is left. Returns the receipts re-scored and the note, if any."""
+    import sys
+
+    from ..store.finish import settle_rule_receipts
+    from ..store.home import Store
+
+    try:
+        out = settle_rule_receipts(Store(home))
+    except Exception as exc:  # the fit goes on; the receipts wait for the next one
+        note = f"receipts scored before 0.2.7 were not re-scored: {type(exc).__name__}: {exc}"[:300]
+        print(f"note: {note}", file=sys.stderr)
+        return [], note
+    failed = out["failed"]
+    if not failed:
+        return out["rescored"], None
+    shown = "; ".join(failed[:3]) + (f"; and {len(failed) - 3} more" if len(failed) > 3 else "")
+    note = f"receipts scored before 0.2.7 are not all settled yet; the next fit does what is left: {shown}"
+    print(f"note: {note}", file=sys.stderr)
+    return out["rescored"], note
+
+
 def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), full: bool = False,
         now: datetime | None = None, docs: Iterable[dict] | None = None, bundle_dir: Path | None = None,
         benchmarks: Path | None = None, eb: bool = True, wait_s: float = 0.0) -> Path:
-    """Build the belief and write `fits/<fit>/`; returns its path.
+    """Build the belief and write `fits/<fit>/`; returns its path. A fit of the store's own runs (`docs` None)
+    first settles the receipts scored before 0.2.7 (`_settle_receipts`).
 
-    Raises FitBusy, or UnknownSource / NothingToFit before anything is written.
+    Raises FitBusy, or UnknownSource / NothingToFit before any fit file is written.
     """
     home = Path(home)
     fits = home / "fits"
@@ -527,6 +590,7 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
     without = tuple(without)
     with fit_lock(home, wait_s):
         remove_partials(home)
+        settled, settle_note = _settle_receipts(home) if docs is None else ([], None)
         config = _read_config(home)
         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)
@@ -572,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"
@@ -610,7 +677,10 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
         _atomic_json(partial / "design.json", design)
         meta = {
             "fit": fit_id, "created_at": now.isoformat(timespec="seconds"), "code_version": _code_version(),
-            "seed_key": seed_key, "timebox_effort": design_rows.TIMEBOX_EFFORT_COST,
+            "seed_key": seed_key, **({"outcome_q": custom_q(q_by_tier)} if custom_q(q_by_tier) else {}),
+            **({"receipts_rescored": len(settled)} if settled else {}),
+            **({"notes": [settle_note]} if settle_note else {}),
+            "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_weights": bench_weights},
@@ -636,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-0.2.6 → loopmath-0.2.8}/src/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"]