loopmath 0.2.6__tar.gz → 0.2.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmath
-Version: 0.2.6
+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 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.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 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.7}/pyproject.toml

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

{loopmath-0.2.6 → loopmath-0.2.7}/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.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.6 → 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.6 → 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.6 → 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.6 → loopmath-0.2.7}/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.7}/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.7}/src/loopmath/belief/design.py

@@ -720,6 +720,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 +735,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 +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(), 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.7}/src/loopmath/belief/fit.py

@@ -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)
@@ -206,6 +208,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] = {}
@@ -277,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
@@ -396,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")
@@ -404,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())
@@ -413,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()
 
@@ -513,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"
@@ -527,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)
@@ -610,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.6 → 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.7/src/loopmath/belief/rules.py

@@ -0,0 +1,139 @@
+"""One acceptance-rule resolver for the fit, `run finish` and its receipts, the share export and the runs view.
+
+Before 0.2.7 the four readers each parsed `run.acceptance_rule` their own way. They now all call
+`resolve_rule` and `evidence`, which give the fit's answers:
+
+- `stored_rule(doc)` is the rule the fit has always read (`design.rule_from_doc`): a rule with no name is the
+  default, `window_days: 0` is 14 days and an empty `excludes_events` is revert and incident.
+- The review case: a run onboarded from the logs, or stored by `run import` from 0.2.7, whose stored rule is
+  absent or the default (named `tests`, requiring exactly `tests`, no score), that has no `tests` verdict and
+  has a `review` or `accepted` verdict, is read by the review rule. So is a run that `loopmath outcome --rule
+  review` moved, whose stored rule carries the review mark.
+- The review rule's reading: the latest `review` or `accepted` verdict, by observed time. Accept, approve and
+  pass are a success, reject and fail are not; any other value gives no outcome, with the reason
+  `unknown:review=<value>`. Late events, the window and q work as for any rule.
+
+Only a rule with the review mark (`ext["dev.loopmath.rule"] = {"reading": "review"}`) is read this way, so a
+user's own rule named `review` keeps its reading.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from datetime import datetime
+from typing import Any
+
+from ..types import DEFAULT_RULE, AcceptanceRule, Evidence
+from .design import rule_from_doc
+from .outcome import _last, outcome_evidence
+
+RULE_EXT = "dev.loopmath.rule"
+IMPORT_EXT = "dev.loopmath.import"
+STORED_BY_IMPORT = "run import"
+REVIEW_COMMAND = "loopmath outcome --rule review"
+REVIEW_NAMES = ("review", "accepted")
+REVIEW_PASS = ("accept", "approve", "pass")
+REVIEW_FAIL = ("reject", "fail")
+REVIEW_RULE = AcceptanceRule(
+    name="review", definition="the latest review or accepted verdict is accept, approve or pass",
+    requires=("review",), extra={"ext": {RULE_EXT: {"reading": "review"}}})
+
+
+def stored_rule(doc: dict) -> AcceptanceRule:
+    """The rule recorded on the run as the fit reads it. Raises ValueError or TypeError on a malformed score."""
+    return rule_from_doc(doc)
+
+
+def is_review_rule(rule: AcceptanceRule | dict | None) -> bool:
+    """A rule that carries the review mark (a rule object, or a rule as stored on a run)."""
+    if isinstance(rule, AcceptanceRule):
+        ext = rule.extra.get("ext")
+    elif isinstance(rule, dict):
+        ext = rule.get("ext")
+    else:
+        return False
+    mark = ext.get(RULE_EXT) if isinstance(ext, dict) else None
+    return isinstance(mark, dict) and mark.get("reading") == "review"
+
+
+def review_rule_dict() -> dict[str, Any]:
+    """The review rule as `outcome --rule review` stores it on a run."""
+    return {k: v for k, v in REVIEW_RULE.to_dict().items() if v is not None}
+
+
+def _verdicts(doc: dict) -> list[dict]:
+    signals = (doc.get("run") or {}).get("signals") or []
+    return [s for s in signals if isinstance(s, dict) and s.get("kind") == "verdict"]
+
+
+def is_marked_import(doc: dict) -> bool:
+    ext = (doc.get("run") or {}).get("ext")
+    mark = ext.get(IMPORT_EXT) if isinstance(ext, dict) else None
+    return isinstance(mark, dict) and mark.get("stored_by") == STORED_BY_IMPORT
+
+
+def has_default_rule(doc: dict) -> bool:
+    """The stored rule is absent, or named `tests` and requiring exactly `tests`, with no score."""
+    try:
+        rule = stored_rule(doc)
+    except (TypeError, ValueError):
+        return False
+    return rule.name == "tests" and tuple(rule.requires) == ("tests",) and rule.score is None
+
+
+def review_only(doc: dict) -> bool:
+    """No `tests` verdict, and a `review` or `accepted` one."""
+    names = {s.get("name") for s in _verdicts(doc)}
+    return "tests" not in names and bool(names & set(REVIEW_NAMES))
+
+
+def in_review_case(doc: dict) -> bool:
+    from ..store.runs import is_history
+
+    return (is_history(doc) or is_marked_import(doc)) and has_default_rule(doc) and review_only(doc)
+
+
+def could_use_review_rule(doc: dict, rule: AcceptanceRule, z: float | None) -> bool:
+    """A run `loopmath outcome --rule review` could help, as `runs` lists it: finished, read under another rule
+    with no outcome, with no `tests` verdict and a `review` or `accepted` one."""
+    from ..store.runs import is_finished
+
+    return z is None and not is_review_rule(rule) and is_finished(doc) and review_only(doc)
+
+
+def resolve_rule(doc: dict) -> AcceptanceRule:
+    """The rule every reader applies to this run. Raises as `stored_rule` does on a malformed score."""
+    raw = (doc.get("run") or {}).get("acceptance_rule")
+    if is_review_rule(raw) or in_review_case(doc):
+        return REVIEW_RULE
+    return stored_rule(doc)
+
+
+def resolve_rule_or_default(doc: dict) -> AcceptanceRule:
+    """`resolve_rule`, with the default rule for a malformed stored rule (receipts and views; the fit drops such a
+    run instead)."""
+    try:
+        return resolve_rule(doc)
+    except (TypeError, ValueError):
+        return DEFAULT_RULE
+
+
+def evidence(doc: dict, rule: AcceptanceRule, *, now: datetime,
+             q_by_tier: dict[str, float] | None = None) -> Evidence:
+    """The run's outcome under `rule`: the review reading for the review rule, `outcome_evidence` otherwise."""
+    if not is_review_rule(rule):
+        return outcome_evidence(doc, rule, now=now, q_by_tier=q_by_tier)
+    run = doc.get("run") or {}
+    signals = [s for s in run.get("signals") or [] if isinstance(s, dict)]
+    named = [s for s in signals if s.get("kind") == "verdict" and s.get("name") in REVIEW_NAMES]
+    latest = _last(named)
+    value = str(latest.get("value") or "").lower() if latest is not None else None
+    reading = "accept" if value in REVIEW_PASS else "reject" if value in REVIEW_FAIL else None
+    kept = [s for s in signals if not (s.get("kind") == "verdict" and s.get("name") in REVIEW_NAMES)]
+    if reading is not None:
+        kept.append({**latest, "name": "review", "value": reading})
+    ev = outcome_evidence({**doc, "run": {**run, "signals": kept}}, rule, now=now, q_by_tier=q_by_tier)
+    if latest is not None and reading is None:
+        reasons = tuple(f"unknown:review={value}" if r == "missing:review" else r for r in ev.reasons)
+        ev = dataclasses.replace(ev, reasons=reasons)
+    return ev

{loopmath-0.2.6 → loopmath-0.2.7}/src/loopmath/cli_registry.py

@@ -227,7 +227,10 @@ def _add_recording(sub) -> None:
                    "Claude Code session id, a Codex thread id, or self for this Claude Code session (repeatable); "
                    "PIECE= names its piece; run sessions lists the ids. Only the part of a session inside the window "
                    "counts; 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")
+                   "the reading's time, a reading on either edge included. A sub-agent or Codex child thread counts in "
+                   "full when it started inside the window, not at all when it started before; a Codex reading lower "
+                   "than the one before it (a compaction reset) counts from zero; a Codex session with a reading that "
+                   "has no time, or whose increases inside the window add up to less than zero, counts whole, with a note")
     q.add_argument("--cwd", action="append", default=[], metavar="[PIECE=]PATH", help="a folder an agent with no session id "
                    "worked in; its log is matched at finish by folder and time (repeatable)")
     q.add_argument("--since", default=None, metavar="TS", help="when the work began (e.g. 2h or a local ISO time); with "
@@ -256,6 +259,14 @@ def _add_recording(sub) -> None:
     target.add_argument("--run", default=None, metavar="RUN", help="the run the signal is about")
     target.add_argument("--slate", default=None, metavar="SLT", help="the slate a preference is about (with --prefer)")
     target.add_argument("--commit", default=None, metavar="SHA", help="late event: find runs by commit")
+    target.add_argument("--rule", default=None, metavar="NAME",
+                        help="review: judge each RUN by its latest review or accepted verdict (accept, approve or "
+                        "pass is a success); --undo-rule undoes that, and so does naming the rule a run had before "
+                        "(tests when it had none) unless it is named review. A run with a tests verdict is refused, "
+                        "and nothing is written if any RUN is refused")
+    target.add_argument("--undo-rule", action="store_true",
+                        help="restore each RUN's rule from before --rule review moved it, exactly as it was")
+    p.add_argument("rule_runs", nargs="*", default=[], metavar="RUN", help="with --rule or --undo-rule: the runs to move")
     p.add_argument("--signal", default=None, metavar="NAME=VALUE", help="NAME= (empty) declares an unmeasured score")
     p.add_argument("--kind", default="verdict", choices=["verdict", "score", "event"], help="what the signal is (default verdict)")
     p.add_argument("--unit", default=None, metavar="U", help="score unit")
@@ -294,6 +305,12 @@ def _add_recording(sub) -> None:
     q.add_argument("value", metavar="VALUE")
     _common(q)
     q.set_defaults(func=_lazy("loopmath.store.commands:config_set"))
+    q = cs.add_parser("unset", help="remove one key, so it reads its default",
+                      description="Removes one key from config.toml and keeps every other line, comments too. "
+                                  "A key that is not in the file is not an error.")
+    q.add_argument("key", metavar="KEY")
+    _common(q)
+    q.set_defaults(func=_lazy("loopmath.store.commands:config_unset"))
 
 
 LABELER_KINDS = ("claude", "codex", "command")

{loopmath-0.2.6 → loopmath-0.2.7}/src/loopmath/graph/html_common.py

@@ -453,13 +453,13 @@ ${a.hint ? `<dt>hint</dt><dd class="mono">${esc(a.hint)}</dd>` : ''}</dl>`;
   }
   function renderFoot() {
     const kinds = RUN.edges_by_kind_tier || {};
-    const unpriced = N.filter(n => n.usd == null).length;
+    const unpriced = N.filter(n => n.usd == null).length, many = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
     // Up to three of this page's own names, in start order: one per name prefix first, then the next ones.
     const picked = [], prefixes = new Set();
     N.forEach((n, i) => { const prefix = String(n.lbl).replace(/-\d+$/, ''); if (picked.length < 3 && !prefixes.has(prefix)) { prefixes.add(prefix); picked.push(i); } });
     N.forEach((n, i) => { if (picked.length < 3 && !picked.includes(i)) picked.push(i); });
     const names = picked.sort((a, b) => a - b).map(i => esc(N[i].lbl)).join(', ');
-    $('foot').innerHTML = `Data: ${esc(RUN.source)}. Workspace ${esc(RUN.workspace)}, ${fmt.ts(RUN.start)} to ${fmt.ts(RUN.end)}. ${N.length} attempts, ${E.length} of ${RUN.n_source_edges} supplied edges shown (${Object.entries(kinds).map(([key, value]) => value + ' ' + key.replace('/', ' ')).join(', ')}), ${RUN.n_artifacts} artifacts of which ${RUN.n_consumed} were read by another attempt. Known cost ${fmt.usd(N.reduce((sum, n) => sum + (n.usd == null ? 0 : n.usd), 0))} with ${unpriced} unpriced attempt. Attempt status is unavailable because the graph model carries no acceptance signal. Attempt names${names ? ` (${names})` : ''} are display names assigned in start order, from the role or, for an attempt with no known role, from the tool that ran it; hover a name for the mapped attempt id. Edge tiers: verified means both ends are present in the logs, heuristic means inferred from timing or text. Self-contained page, no external assets.`;
+    $('foot').innerHTML = `Data: ${esc(RUN.source)}. Workspace ${esc(RUN.workspace)}, ${fmt.ts(RUN.start)} to ${fmt.ts(RUN.end)}. ${many(N.length, 'attempt')}, ${E.length} of ${RUN.n_source_edges} supplied edges shown (${Object.entries(kinds).map(([key, value]) => value + ' ' + key.replace('/', ' ')).join(', ')}), ${many(RUN.n_artifacts, 'artifact')} of which ${RUN.n_consumed} ${RUN.n_consumed === 1 ? 'was' : 'were'} read by another attempt. Known cost ${fmt.usd(N.reduce((sum, n) => sum + (n.usd == null ? 0 : n.usd), 0))} with ${many(unpriced, 'unpriced attempt')}. Attempt status is unavailable because the graph model carries no acceptance signal. Attempt names${names ? ` (${names})` : ''} are display names assigned in start order, from the role or, for an attempt with no known role, from the tool that ran it; hover a name for the mapped attempt id. Edge tiers: verified means both ends are present in the logs, heuristic means inferred from timing or text. Self-contained page, no external assets.`;
   }
 
   const api = { N, E, A, RUN, ROLES, MODELS, ROLE_COLOR, MODEL_COLOR, MAX_USD, fmt, esc, roleName, color, dashed, radius, svg, text, curve, vcurve, arc, timeTicks, edgeClass, nodeClass, edgeVisible, artVisible };