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

loopmath/__init__.py

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

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/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/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/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/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/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/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/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/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/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/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/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

loopmath/belief/priors.py

@@ -1,17 +1,17 @@
 """Prior bundle and benchmark prior factors (spec 04 section 5).
 
-- The shipped bundle (lane 11) enters the fit as data, each run under its `source` node
-  (`sweep`, `e0`, `rq1`, `repo_history`). `bundle_docs()` reads it through lane 11's
+- The shipped bundle enters the fit as data, each run under its `source` node
+  (`sweep`, `e0`, `rq1`, `repo_history`). `bundle_docs()` reads it through
   `loopmath.priors.bundle_docs()`; `bundle_entries()` pairs each run with its manifest
   source, so a store run with a shipped label stays the user's.
-- Shared imports (lane 8) enter under their `shared:<org>` source through
+- Shared imports enter under their `shared:<org>` source through
   `share.import_.shared_runs(home)`.
 - Benchmark priors (`priors/benchmarks.toml`, layout D36) become Gaussian prior factors on
   version nodes: success head, the logit gap to the benchmark's reference model with variance
   `1 / (w p (1 - p))`; cost head, the log cost ratio with variance `1 / w`; tokens head
   (`kind = "tokens"`, published total tokens for the evaluation), the log token ratio
-  with variance `1 / w`. `w` is one model's share of the benchmark's weight `w_b` (0.2.3,
-  lane 23K): the `weight` of its `[[benchmark]]` table (default 5, about 5 runs), shared by
+  with variance `1 / w`. `w` is one model's share of the benchmark's weight `w_b` (0.2.3):
+  the `weight` of its `[[benchmark]]` table (default 5, about 5 runs), shared by
   the model's k results on that benchmark, so each gets `w_b / k` and a model with five
   efforts pulls as hard in total as a model with one. Config `benchmark_prior_weight`, when
   set, is one `w_b` for every benchmark; 0 turns the factors off.
@@ -33,38 +33,38 @@ PACKAGE_PRIORS = Path(__file__).resolve().parent.parent / "priors"
 
 
 def bundle_docs(bundle_dir: Path | None = None, without: tuple[str, ...] = ()) -> Iterator[dict]:
-    """OCP v0.3 run documents of the shipped prior bundle, or of `bundle_dir` (lane 11's reader)."""
-    from .. import priors as lane11
+    """OCP v0.3 run documents of the shipped prior bundle, or of `bundle_dir`, read by `loopmath.priors`."""
+    from .. import priors as bundle
 
-    yield from lane11.bundle_docs(without=tuple(without), directory=bundle_dir)
+    yield from bundle.bundle_docs(without=tuple(without), directory=bundle_dir)
 
 
 def bundle_entries(bundle_dir: Path | None = None) -> Iterator[tuple[str, dict]]:
     """(manifest source, document) for every shipped run: the fit's source for it (spec 04 section 1)."""
-    from .. import priors as lane11
+    from .. import priors as bundle
 
-    yield from lane11.bundle_entries(directory=bundle_dir)
+    yield from bundle.bundle_entries(directory=bundle_dir)
 
 
 def run_id_of(doc: dict) -> str:
-    from .. import priors as lane11
+    from .. import priors as bundle
 
-    return lane11.run_id_of(doc)
+    return bundle.run_id_of(doc)
 
 
 def bundle_sources(bundle_dir: Path | None = None) -> list[str]:
-    """Source names in the shipped prior bundle, or in `bundle_dir` (lane 11's manifest).
+    """Source names in the shipped prior bundle, or in `bundle_dir` (from its manifest).
 
     Read from `manifest()`: the package attribute `sources` turns into the `priors.sources`
     submodule once anything imports it, so calling it fails in a full run.
     """
-    from .. import priors as lane11
+    from .. import priors as bundle
 
-    return list(lane11.manifest(bundle_dir).get("sources") or {})
+    return list(bundle.manifest(bundle_dir).get("sources") or {})
 
 
 def shared_docs(home: Path) -> Iterator[dict]:
-    """Runs imported from other organizations (lane 8's `shared_runs`)."""
+    """Runs imported from other organizations (`share.import_.shared_runs`)."""
     from ..share.import_ import shared_runs
 
     yield from shared_runs(home)
@@ -116,7 +116,7 @@ def benchmark_factors(path: Path | None = None, *, weight: float | None = None)
 
     `weight` (config `benchmark_prior_weight`) overrides every benchmark's own weight; None reads
     each benchmark's `weight`. A model's k results on one benchmark share its weight: each factor
-    has weight `w_b / k` (B1). A benchmark with weight 0 or less gives no factors.
+    has weight `w_b / k`. A benchmark with weight 0 or less gives no factors.
     """
     path = path or benchmark_path()
     if not path.is_file():
@@ -154,7 +154,7 @@ def benchmark_factors(path: Path | None = None, *, weight: float | None = None)
             elif kind in ("cost", "tokens") and value > 0 and ref_value > 0:  # Tokens feed the tokens head only
                 by_model.setdefault(model, []).append((kind, terms, math.log(value / ref_value), r))
         for model, items in by_model.items():
-            w = w_b / len(items)  # one budget per model and benchmark (B1)
+            w = w_b / len(items)  # one budget per model and benchmark
             share = f"weight {w_b:g} over {len(items)}" if len(items) > 1 else f"weight {w_b:g}"
             for head, terms, mean, r in items:
                 note = (f"{bid}: {model} {float(r['value'])} against {ref} {ref_value} ({share}; "