loopmath 0.2.5__tar.gz → 0.2.7__tar.gz

{loopmath-0.2.5/src/loopmath.egg-info → loopmath-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmath
-Version: 0.2.5
+Version: 0.2.7
 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 whole). 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.5 → loopmath-0.2.7}/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 whole). 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.5 → loopmath-0.2.7}/pyproject.toml

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

{loopmath-0.2.5 → loopmath-0.2.7}/src/loopmath/adapters/atrium.py

@@ -5,12 +5,12 @@ 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.
 
 The source has no token counts, cost, model, effort, stable task node, or
-acceptance result. Its locally inspected data is stale since 2026-08-14 and
+acceptance result. Locally inspected data can be weeks stale, and
 its pane-to-session coverage is sparse. SQL projection excludes prompt,
 message, title, body, transcript, actor, and task text before rows reach
 Python; none is retained or emitted.
@@ -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.5 → loopmath-0.2.7}/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.5 → loopmath-0.2.7}/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.5 → loopmath-0.2.7}/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.5 → loopmath-0.2.7}/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.5 → loopmath-0.2.7}/src/loopmath/adapters/paseo.py

@@ -9,7 +9,7 @@ evidence that the work was accepted.
 The vendor-session join is mechanically supported when
 ``persistence.sessionId`` equals both available native corroborators,
 ``persistence.nativeHandle`` and ``runtimeInfo.sessionId``. The matching value
-is emitted as ``attempt.session``. Read-only inspection on 2026-09-02 also
+is emitted as ``attempt.session``. A read-only inspection also
 matched every local value to a Claude or Codex session filename without reading
 transcripts. This is a verified identity correlation, not a graph relation.
 Paseo records no distinct launcher or parent endpoint, so this adapter emits no
@@ -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.5 → loopmath-0.2.7}/src/loopmath/belief/commands.py

@@ -1,11 +1,11 @@
-"""Handler for `loopmath fit` (spec 02, lane 5).
+"""Handler for `loopmath fit` (spec 02).
 
 `loopmath fit [--background] [--full] [--no-prior] [--without SOURCE ...] [--home PATH] [--json]`
 
 - Foreground: builds the belief (belief.fit.fit), waiting up to 30 s for a running fit to
   finish (exit 4 after that), and prints a summary or `loopmath.fit/1` JSON.
 - `--background`: detaches and returns at once through the store's fit trigger
-  (`store.fitjob.spawn_fit`, lane 7), so a running fit queues one more fit instead of
+  (`store.fitjob.spawn_fit`), so a running fit queues one more fit instead of
   racing it.
 - A `--without` name that matches no source exits 2 and lists the known names; a fit
   with nothing to fit writes nothing, leaves `fits/latest` where it was and exits 1.
@@ -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.5 → loopmath-0.2.7}/src/loopmath/belief/design.py

@@ -36,7 +36,7 @@ HEURISTIC_COST_WEIGHT = 0.7  # spec 04 section 2 and D27: allocated (heuristic)
 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)
 RQ1_EXT = "dev.loopmath.rq1"  # loopmath-exp's ext key; its horizon_s is the fallback for older RQ1 runs
-# 0.2.1 (F5, spec 04 section 1): in the cost and tokens rows of a timeboxed task the terms a timebox caps (effort
+# 0.2.1 (spec 04 section 1): in the cost and tokens rows of a timeboxed task the terms a timebox caps (effort
 # and shape) enter at this value, not 1. Set from the RQ1 2 h runs: open-ended effort terms gave max over low x2.64
 # (solo luna) and x2.23 (solo sol) against x1.34 and x1.27 observed; ln 1.34 / ln 2.64 = ln 1.27 / ln 2.23 = 0.30.
 TIMEBOX_EFFORT_COST = 0.3
@@ -465,7 +465,7 @@ def source_label(doc: dict) -> str:
     share = ext.get("dev.loopmath.share")
     if isinstance(share, dict):
         # 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 at all the source is `shared`, the name `fit --without shared` takes (0.2.3)
         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:")
@@ -640,7 +640,7 @@ def _ocp_fields(cost: dict) -> dict[str, float]:
 
 def _price_split(split: dict, table) -> float | None:
     """Dollars for `{model: OCP token fields}`, each model at its own current rate, summed; None when any
-    part is unpriced or unlabelled (lane 02's `price.price_model_tokens`)."""
+    part is unpriced or unlabelled (`price.price_model_tokens`)."""
     from ..price import price_model_tokens
 
     usd = price_model_tokens(split, table).get("usd")
@@ -720,14 +720,21 @@ 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) -> ParsedRun:
+              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.
 
-    `origin` is where the fit found the document (`data_source`); None reads its label.
+    `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):
@@ -785,8 +792,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())
+    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.5 → loopmath-0.2.7}/src/loopmath/belief/fit.py

@@ -4,7 +4,7 @@ Spec 04 section 4. `fit()` reads finished OCP v0.3 runs (the store, the shipped
 shared imports), builds the rows of every head, sets the level scales by empirical Bayes,
 and writes `fits/<fit>.partial/{state.npz, meta.json, design.json}`, renamed to
 `fits/<fit>/` when complete; `fits/latest` then points at it. A non-blocking `flock` on
-`fits/.fit.lock` stops two fits running together (lane 7's trigger has its own job lock on
+`fits/.fit.lock` stops two fits running together (the store's fit trigger has its own job lock on
 `fits/.lock`, so the two never wait on each other).
 """
 
@@ -136,7 +136,7 @@ def _nothing_to_fit(no_prior: bool, without: tuple[str, ...], dropped: dict[str,
 # ---------------------------------------------------------------- reading documents
 
 def store_docs(home: Path) -> Iterator[dict]:
-    """Finished run documents in the store, through lane 7's reader (it decides what is finished)."""
+    """Finished run documents in the store, through the store's reader (it decides what is finished)."""
     from ..store.home import Store
 
     yield from Store(home).finished_docs()
@@ -146,7 +146,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 +165,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)
@@ -183,7 +185,8 @@ def _excluded(source: str, without: tuple[str, ...]) -> bool:
 
 
 def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tuple[str, ...] = (),
-                 now: datetime | None = None, features: FeatureSet | None = None):
+                 now: datetime | None = None, features: FeatureSet | None = None,
+                 q_by_tier: dict[str, float] | None = None):
     """Rows of every head from run documents, plus counts of what was used and dropped.
 
     `docs` yields documents, or `(origin, document)` pairs from `fit()`: `user` for the store
@@ -199,11 +202,13 @@ def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tup
     their document names, when that is not `user`. Features are read with `features` (the
     built-ins by default); only admitted values keep their `feature:` terms, and `tally`
     (features.FeatureTally) holds the support, the admitted values and the recorded horizons.
+    `q_by_tier` (`outcome.q.<tier>` from config.toml) reaches each run's outcome; None is the built-in q.
     """
     now = now or datetime.now().astimezone()
     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] = {}
@@ -232,7 +237,7 @@ def collect_rows(docs: Iterable[dict | tuple[str | None, dict]], *, without: tup
                 dropped[SHIPPED_COPY] += 1
                 continue
         try:
-            pr = parse_run(doc, now=now, origin=origin)
+            pr = parse_run(doc, now=now, origin=origin, q_by_tier=q_by_tier)
         except Unusable as exc:
             dropped[str(exc)] += 1
             continue
@@ -275,6 +280,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
@@ -394,6 +401,16 @@ 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")
@@ -402,7 +419,10 @@ 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
     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)."""
     h = hashlib.sha256()
     h.update(repr((DESIGN_VERSION, design_rows.TIMEBOX_EFFORT_COST, design_rows.TIMEBOX_LEVELS,
                    sorted(settings.items()))).encode())
@@ -411,7 +431,8 @@ def input_key(heads_rows: dict[str, HeadRows], specs: list, settings: dict) -> s
     for name in sorted(heads_rows):
         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()
 
@@ -511,12 +532,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"
@@ -525,6 +572,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)
@@ -532,6 +580,11 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
             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
             features, features_error = FeatureSet(), str(exc)
+        from ..store.config import Config
+        from .outcome import TIER_Q
+
+        # `outcome.q.<tier>`, read as `run finish` reads it; unset, the built-in q (0.2.6, fix (1))
+        q_by_tier = {tier: Config(home / "config.toml", config).q_for_tier(tier) for tier in TIER_Q}
 
         def all_docs() -> Iterator[dict | tuple[str | None, dict]]:
             if docs is not None:
@@ -544,7 +597,7 @@ def fit(home: Path, *, no_prior: bool = False, without: tuple[str, ...] = (), fu
                 yield from prior_data.shared_docs(home)
 
         (heads_rows, score_info, dropped, runs_by_source, config_support, checks, overlap,
-         labels, tally) = collect_rows(all_docs(), without=without, now=now, features=features)
+         labels, tally) = collect_rows(all_docs(), without=without, now=now, features=features, q_by_tier=q_by_tier)
         removed = {k[len("without "):] for k in dropped if k.startswith("without ")}
         unknown, known = unknown_sources(without, set(runs_by_source) | removed, bundle_dir)
         if unknown:
@@ -603,7 +656,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},

{loopmath-0.2.5 → loopmath-0.2.7}/src/loopmath/belief/forest.py

@@ -85,7 +85,7 @@ ROLE_WORDS = ("planner", "implementer", "reviewer", "tester", "referee", "worker
 
 
 def canonical_role(role: str | None) -> str:
-    """Fold a role word into the types.py vocabulary through `workflows.normalize_role()` (lane 4);
+    """Fold a role word into the types.py vocabulary through `workflows.normalize_role()`;
     no role is `worker`."""
     return _canonical_role(str(role or "").strip().lower())
 
@@ -107,7 +107,7 @@ _GPT_RE = re.compile(r"^gpt-(\d+(?:\.\d+)?)(?:-(.+))?$")
 def canonical_model_id(model: str | None) -> str:
     """One spelling per model: `claude-opus-5-5`, `claude-haiku-4-5`, `gpt-6-astra`.
 
-    Passes through `ingest.base.canonical_model` first (lane 2 owns its aliases), then
+    Passes through `ingest.base.canonical_model` first (it owns the aliases), then
     rewrites Claude ids to the `claude-<family>-<major>[-<minor>]` form of spec 04.
     """
     from ..ingest.base import canonical_model

{loopmath-0.2.5 → loopmath-0.2.7}/src/loopmath/belief/outcome.py

@@ -9,7 +9,8 @@
   with reason `late:<name>`.
 - `q` comes from the weakest tier used: verified 0.98, reported 0.95, heuristic 0.8, asserted 0.7.
 - `scores`: every measured score, raw, whatever the rule is.
-- D22: a shared run (`run.ext["dev.loopmath.share"]`) returns the sender's carried evidence.
+- D22: a shared run (`run.ext["dev.loopmath.share"]`) returns the sender's carried outcome; a share that
+  carries no q takes the tier's q from `q_by_tier`.
 """
 
 from __future__ import annotations
@@ -60,17 +61,29 @@ def _last(signals: list[dict]) -> dict | None:
     return indexed[-1][1]
 
 
-def _shared_evidence(share: dict) -> Evidence | None:
-    ev = share.get("evidence") if isinstance(share.get("evidence"), dict) else share
+def _shared_scores(raw: Any) -> dict[str, float]:
+    """A share's scores: the list `share` writes (`{name, value, ...}`), or an object of name to value."""
+    if isinstance(raw, list):
+        pairs = [(s.get("name"), s.get("value")) for s in raw if isinstance(s, dict)]
+    elif isinstance(raw, dict):
+        pairs = list(raw.items())
+    else:
+        return {}
+    return {str(k): float(v) for k, v in pairs if k is not None and _is_number(v)}
+
+
+def _shared_evidence(share: dict, qmap: dict[str, float]) -> Evidence | None:
+    """The outcome a shared run carries: `outcome` as `share` writes it, else an `evidence` object or z and q
+    at the top of the ext (older shapes). With no carried q, `qmap` gives the tier's q, as for a local run."""
+    ev = next((share[k] for k in ("outcome", "evidence") if isinstance(share.get(k), dict)), share)
     if "z" not in ev and "q" not in ev:
         return None
     z = ev.get("z")
     tier = _tier(ev.get("tier"))
     q = ev.get("q")
-    scores = share.get("scores") if isinstance(share.get("scores"), dict) else ev.get("scores") or {}
-    return Evidence(z=None if z is None else float(z), q=float(q) if q is not None else TIER_Q[tier], tier=tier,
-                    scores={str(k): float(v) for k, v in (scores or {}).items() if _is_number(v)},
-                    reasons=("shared",))
+    scores = share.get("scores") if share.get("scores") is not None else ev.get("scores")
+    return Evidence(z=None if z is None else float(z), q=float(q) if q is not None else float(qmap[tier]), tier=tier,
+                    scores=_shared_scores(scores), reasons=("shared",))
 
 
 def outcome_evidence(run_doc: dict, rule: AcceptanceRule, *, now: datetime,
@@ -79,7 +92,7 @@ def outcome_evidence(run_doc: dict, rule: AcceptanceRule, *, now: datetime,
     run = run_doc.get("run") or {}
     share = (run.get("ext") or {}).get("dev.loopmath.share")
     if isinstance(share, dict):
-        carried = _shared_evidence(share)
+        carried = _shared_evidence(share, qmap)
         if carried is not None:
             return carried
 

{loopmath-0.2.5 → loopmath-0.2.7}/src/loopmath/belief/pricing.py

@@ -1,4 +1,4 @@
-"""The price offset on the cost head (spec 04 section 2, 0.2.2, lane 22C).
+"""The price offset on the cost head (spec 04 section 2, 0.2.2).
 
 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