loopmath 0.2.4__py3-none-any.whl → 0.2.6__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.4"
+__version__ = "0.2.6"

loopmath/adapters/atrium.py

@@ -10,7 +10,7 @@ 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.

loopmath/adapters/opencode.py

@@ -103,7 +103,7 @@ _sys.modules[__name__].__class__ = _OpenCodeModule
 del _ModuleType, _OpenCodeModule, _opencode_store, _sys
 
 
-_EXT = "dev.dagr.adapter.opencode"
+_EXT = "dev.loopmath.adapter.opencode"
 
 def _session_created(session: _SessionSource) -> datetime | None:
     return _timestamp(_as_mapping(session.info.get("time")).get("created"))

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

loopmath/adapters/pi.py

@@ -2,7 +2,7 @@
 
 One Pi session is one OCP node with one attempt. Usage-bearing entries are
 measured requests: their token and USD fields are summed into the attempt's
-core cost record, while ``dev.dagr.adapter.pi.usage_records`` retains the exact
+core cost record, while ``dev.loopmath.adapter.pi.usage_records`` retains the exact
 per-entry breakdown that OCP v0.2 cannot express. Model labels on assistant
 messages are verified; thinking effort is reported by Pi's explicit
 ``thinking_level_change`` entries.
@@ -57,7 +57,7 @@ from .registry import register
 
 
 _DEFAULT_STORE = Path.home() / ".pi" / "agent" / "sessions"
-_EXT = "dev.dagr.adapter.pi"
+_EXT = "dev.loopmath.adapter.pi"
 
 
 class _PiModule(_ModuleType):

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.

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")
@@ -721,10 +721,11 @@ def _check_name(a: dict, node: dict) -> str | None:
 
 
 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
 
@@ -741,10 +742,19 @@ def parse_run(doc: dict, *, now: datetime | None = None, rule: AcceptanceRule |
 
     nodes = {n.get("id"): n for n in doc.get("nodes") or [] if isinstance(n, dict)}
     node_vertex = {i: n.get("vertex") for i, n in nodes.items()}
+    from ..ocp.membership import imported_node_map
+
+    imported_vertices = imported_node_map(doc)
     attempts: list[AttemptObs] = []
     by_piece_round: dict[tuple[str, int], list[dict]] = {}
     for a in doc.get("attempts") or []:
         piece = a.get("vertex") or node_vertex.get(a.get("node"))
+        node = nodes.get(a.get("node"))
+        if (piece not in st.settings and node is not None and "vertex" not in a and "vertex" not in node
+                and _check_name(a, node) is None):
+            mapped = imported_vertices.get(a.get("node"))
+            if isinstance(mapped, str) and mapped in st.settings:
+                piece = mapped
         if piece not in st.settings:
             name = _check_name(a, nodes.get(a.get("node")) or {})
             if name is not None:
@@ -777,7 +787,7 @@ def parse_run(doc: dict, *, now: datetime | None = None, rule: AcceptanceRule |
 
     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())
+    evidence = outcome_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()
@@ -183,7 +183,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,6 +200,7 @@ 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()
@@ -232,7 +234,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
@@ -532,6 +534,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 +551,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:

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/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}; "

loopmath/builder/__init__.py

@@ -1 +1 @@
-"""`loopmath builder`: the workflow builder (P8), a local page over the fitted model (spec 02, `builder`)."""
+"""`loopmath builder`: the workflow builder, a local page over the fitted model (spec 02, `builder`)."""

loopmath/builder/context.py

@@ -66,8 +66,8 @@ def rec_task(stored: dict[str, Any], args: argparse.Namespace) -> tuple[Task, bo
 
 def asked_task(task: Task, id_given: bool, belief: Any, rule: AcceptanceRule, configs: list) -> Task:
     """The task as `recommend` asks the belief: the user's when they named it, else `commands.question_task`
-    keyed as `recommend` keys it, by `commands.question_key(belief)` once `recommend` has it (0.2.1 lane
-    21F: the fit's input seed key, so identical fits agree), else by the fit id as in 0.2.0."""
+    keyed as `recommend` keys it, by `commands.question_key(belief)` once `recommend` has it (0.2.1:
+    the fit's input seed key, so identical fits agree), else by the fit id as in 0.2.0."""
     if id_given:
         return task
     key_of = getattr(C, "question_key", None)
@@ -307,7 +307,7 @@ def candidate_entry(rec: Recommendation, c: Any) -> dict[str, Any]:
 
 
 def rescue_entry(session: Session, cfg: Configuration) -> dict[str, Any]:
-    """The rescue workflow as a candidate when the search did not offer it (22W N1, 0.2.3): predicted as a
+    """The rescue workflow as a candidate when the search did not offer it (0.2.3): predicted as a
     candidate is, under the recommendation's task, rule and rescue, with origin `rescue`."""
     rec = session.rec
     bands: dict[str, Any] = {}
@@ -334,7 +334,7 @@ def context_payload(session: Session) -> dict[str, Any]:
     offer = [c for c in rec.candidates if c.config.id not in retired]
     top = offer[:TOP_CANDIDATES]
     ids = {c.config.id for c in top}
-    # every option's workflows (the pair's exploration one too) and the rescue workflow, whatever the cutoff (22R B3)
+    # every option's workflows (the pair's exploration one too) and the rescue workflow, whatever the cutoff
     wanted = {rec.usual.config.id, *(i for ch in core["choices"]
                                      for i in (ch["config"], *ch.get("members", ()), ch.get("explore_config")) if i)}
     if rec.rescue_config is not None:

loopmath/builder/predict.py

@@ -2,7 +2,7 @@
 
 A posted configuration is checked (shape, unknown model, width below 1, a gate whose `on_fail` names no
 piece, a piece without a setting) and gets its id as loopmath computes it (`workflows.ids.config_id`, via
-lane 4's `configuration_from_any`), whatever id it was sent with. It is predicted with the fit's
+`configuration_from_any`), whatever id it was sent with. It is predicted with the fit's
 `predict_many` path under the recommendation's task, rule and rescue (`engine.predict_with_medians`, which
 also gives the run cost median the numbers show) and formatted by `Recommendation.numbers()`, so a
 candidate's numbers here equal its numbers in `recommend --json`. Answers are cached by config id.
@@ -26,7 +26,7 @@ from .context import Session, known_models, numbers_of, with_numbers
 CACHE_SIZE = 512
 MAX_MANY = 200  # configurations in one `predict_many` body
 PIECE_KEYS = ("id", "role")
-# 0.2.1 lane 21M: `predict_with_medians` fills `bands` by id and `numbers()` reads `rec.bands`
+# 0.2.1: `predict_with_medians` fills `bands` by id and `numbers()` reads `rec.bands`
 _BANDS = "bands" in inspect.signature(engine.predict_with_medians).parameters
 
 
@@ -136,7 +136,7 @@ def clean(obj: dict[str, Any]) -> tuple[dict[str, Any], list[dict[str, Any]]]:
     return {**obj, "id": None, "settings": settings}, notes
 
 
-# P3-21 (0.2.4): a review gate that names a repairer at a round limit of 1 is one of loopmath's own shapes (reviewed
+# 0.2.4: a review gate that names a repairer at a round limit of 1 is one of loopmath's own shapes (reviewed
 # once; the search builds it and may recommend it). The workflow file check warns about it; the builder page instead
 # says on the gate what 1 round means, so that warning is not shown here.
 REVIEW_ONCE = "budget_rounds is 1"
@@ -154,7 +154,7 @@ def parse_config(obj: Any, models: dict[str, int]
     data, warnings = clean(obj)
     try:
         cfg = configuration_from_any(data)
-    except Exception as exc:  # noqa: BLE001 - lane 4's decoder raises several kinds; the page gets the words
+    except Exception as exc:  # noqa: BLE001 - the workflows decoder raises several kinds; the page gets the words
         return None, [err(None, f"config: {exc}")], []
     errors = notes_of(validate_workflow(cfg.workflow) + validate_settings(cfg.workflow, cfg.settings), cfg)
     for p in cfg.workflow.pieces:
@@ -251,7 +251,7 @@ def failed(cfg: Configuration, exc: Exception) -> dict[str, Any]:
 
 def answer_each(session: Session, cfgs: list[Configuration]) -> list[dict[str, Any]]:
     """`answer_all` in one engine call; when that call fails, one call per configuration, so the configuration
-    that fails gets its own error and the others their answers, however many were cached (22R B2)."""
+    that fails gets its own error and the others their answers, however many were cached."""
     try:
         return answer_all(session, cfgs)
     except Exception as exc:  # noqa: BLE001 - retried one by one below

loopmath/cli.py

@@ -184,8 +184,8 @@ def analyze(args: argparse.Namespace) -> int:
         seed=args.seed,
         ci=args.ci,
     )
-    result["ratio_pair"] = _extremes_ratio(df, result, price_mod)
     result["min_n"] = args.min_n
+    result["ratio_pair"] = _extremes_ratio(df, result, price_mod)
 
     if getattr(args, "json", False):
         from .output import emit_json

loopmath/cli_registry.py

@@ -1,9 +1,9 @@
 """The 0.1.0 command registry (design/0.1/02-commands.md).
 
 Every command and flag of the spec is declared here, and each command points to a
-handler `module:function` in the owning lane's package. Handlers are imported only
-when their command runs, so a lane's unfinished package never breaks `--help` or
-another command. Lanes do not edit this file; a new flag is a request to lane 9.
+handler `module:function` in the owning package. Handlers are imported only
+when their command runs, so a package that fails to import never breaks `--help` or
+another command. A new flag is declared here first.
 """
 
 from __future__ import annotations
@@ -226,7 +226,8 @@ def _add_recording(sub) -> None:
     q.add_argument("--session", action="append", default=[], metavar="[PIECE=]ID", help="a session that worked on the run: a "
                    "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 whole)")
+                   "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")
     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 "
@@ -374,7 +375,7 @@ def _add_viewing(sub) -> None:
     p.add_argument("run_id", nargs="?", default=None, metavar="RUN", help="show this one run in full, as --run RUN")
     p.add_argument("--type", dest="task_type", default=None, metavar="T", help="only this task type (see loopmath task-types)")
     p.add_argument("--repo", default=None, metavar="R", help="only this repository")
-    p.add_argument("--since", default=None, metavar="D", help="only runs started since then: 90d, 2w, 12h, or a date or time such as 2026-09-01 or 2026-09-01T09:00 (local time)")
+    p.add_argument("--since", default=None, metavar="D", help="only runs started since then: 90d, 2w, 12h, or a date or time such as 2026-01-15 or 2026-01-15T09:30 (local time)")
     p.add_argument("--slate", default=None, metavar="SLT", help="only this slate")
     p.add_argument("--run", default=None, metavar="RUN", help="show this one run in full; RUN is an id from the run column of loopmath runs")
     p.add_argument("--wide", action="store_true", help="also show each run's cfg_ configuration id")
@@ -460,7 +461,7 @@ def register(sub) -> None:
     _add_recording(sub)
     _add_learning(sub)
     _add_viewing(sub)
-    importlib.import_module("loopmath.builder.cli").add(sub)  # `builder` (0.2.1 lane 21W)
+    importlib.import_module("loopmath.builder.cli").add(sub)  # `builder` (0.2.1)
 
 
 # Handler targets, for the registry test: every one must import and be callable.

loopmath/cli_support.py

@@ -70,22 +70,16 @@ def _extremes_ratio(df, result, price_mod) -> dict:
     and mixing an adjusted dollar figure with an unadjusted token figure would
     make the ratio of the two meaningless.
 
-    FIX 1 (reviewer round, blocker): the token sum and the dollar sum for a
-    configuration used to each skip their own missing values independently
-    (`.sum(skipna=True)`) while the accepted-run denominator still counted
-    EVERY accepted run in that configuration. A configuration with some
-    unpriced or untokenized runs then got a numerator built from a subset and
-    a denominator built from the whole, understating both ratios -- and the
-    two halves could rest on DIFFERENT subsets (whichever rows happened to
-    have a token count vs. whichever had a price), making their ratio (the
-    amplifier itself) meaningless. Fixed by restricting each configuration to
-    the rows where BOTH `total_tokens` and `usd` are known and computing the
-    token sum, the dollar sum, AND the accepted-run count from that one same
-    restricted set, so numerator and denominator always describe the same
-    runs.
-
-    The reviewer asked instead for the whole comparison to be withheld
-    whenever a single value anywhere is missing. That is NOT what this does:
+    Each configuration is restricted to the rows where BOTH `total_tokens`
+    and `usd` are known, and the token sum, the dollar sum AND the
+    accepted-run count all come from that one restricted set, so numerator
+    and denominator always describe the same runs. Summing each stream over
+    its own known values (`.sum(skipna=True)`) against a count of EVERY
+    accepted run would understate both ratios for a configuration with some
+    unpriced or untokenized runs, and the two halves could rest on DIFFERENT
+    subsets, making their ratio (the amplifier itself) meaningless.
+
+    The comparison is not withheld when a single value anywhere is missing:
     the amplifier is the headline finding of the report, and dropping it
     entirely because one run out of sixty lacks a price would hide more than
     it protects. Disclosing the exact basis is the honest middle ground: when
@@ -93,26 +87,15 @@ def _extremes_ratio(df, result, price_mod) -> dict:
     known-outcome row count, `basis_note` on the returned dict says exactly
     how many runs the numbers rest on and why, for both configurations if
     they differ, and naming neither when nothing was dropped (measured
-    against tonight's real data: nothing is, so this key is not set in the
-    real run -- see the FIX 1 note above `drops` for what "dropped" means
-    now and why it changed).
+    against real data: nothing is, so this key is not set in the
+    real run -- see the note above `drops` for what "dropped" means).
     """
     table = result.get("table")
     n_configs = 0 if table is None else len(table)
     if n_configs < 2:
-        if n_configs == 0:
-            return {
-                "unavailable": (
-                    "no workflow configuration met the minimum run count, so there "
-                    "is nothing to compare"
-                )
-            }
-        return {
-            "unavailable": (
-                "only one workflow configuration met the minimum run count, so "
-                "there is nothing to compare"
-            )
-        }
+        from .report.eligibility import unavailable_lines
+
+        return {"unavailable": "; ".join(unavailable_lines(result, n_configs))}
     ordered = table.sort_values("cost_per_accepted")
     cheap = ordered.iloc[0]["arm"]
     dear = ordered.iloc[-1]["arm"]
@@ -124,19 +107,17 @@ def _extremes_ratio(df, result, price_mod) -> dict:
     # both-known restriction actually dropped a ROW, in `(dear, cheap)`
     # order; feeds `basis_note` below.
     #
-    # FIX 1 (final reviewer round, blocker): this used to compare ACCEPTED
-    # counts (`n_acc` against `n_acc_all`) to decide whether anything was
-    # dropped. But the numerator (`tokens`, `usd` below) is a sum over every
+    # Whether anything was dropped is decided on ROW counts (`len(sub)`
+    # against `len(sub_all)`), not on ACCEPTED counts (`n_acc` against
+    # `n_acc_all`). The numerator (`tokens`, `usd` below) is a sum over every
     # row in `sub` -- accepted AND rejected alike, per the comment on
-    # `sub_all` -- while `n_acc`/`n_acc_all` only ever count accepted rows.
-    # A REJECTED row that has a known acceptance outcome but is missing its
-    # token count or dollar cost gets dropped from `sub` by the both-known
-    # filter below, shrinking the numerator, yet it was never part of either
-    # accepted count to begin with, so `n_acc == n_acc_all` stayed true and
-    # `basis_note` never fired: the understated spend went unreported. Fixed
-    # by comparing ROW counts (`len(sub)` against `len(sub_all)`), which is
-    # the actual population the numerator sums over, and wording the note as
-    # runs actually used out of runs considered rather than "accepted" runs.
+    # `sub_all`. A REJECTED row that has a known acceptance outcome but is
+    # missing its token count or dollar cost is dropped from `sub` by the
+    # both-known filter below, shrinking the numerator, yet it is in neither
+    # accepted count, so comparing accepted counts would never fire
+    # `basis_note` and the understated spend would go unreported. The note
+    # is worded as runs actually used out of runs considered, not "accepted"
+    # runs.
     drops: list[tuple[str, int, int]] = []
     for arm in (dear, cheap):
         # `sub_all`: every row for this configuration with a KNOWN acceptance
@@ -155,7 +136,7 @@ def _extremes_ratio(df, result, price_mod) -> dict:
                 )
             }
 
-        # FIX 1: restrict to rows where BOTH streams are known, then take the
+        # Restrict to rows where BOTH streams are known, then take the
         # token sum, the dollar sum, AND the accepted count from this SAME
         # restricted set -- never a subset for one half and the whole set for
         # the other.
@@ -220,11 +201,11 @@ def _extremes_ratio(df, result, price_mod) -> dict:
     pair["label"] = f"{dear} vs {cheap}"
     pair["basis"] = "per accepted run"
     if drops:
-        # FIX 1: name exactly what was dropped rather than staying silent
-        # about it; report both configurations' counts when they differ, one
-        # when only one configuration lost any rows. Worded as runs actually
-        # used out of runs considered (row counts), not accepted counts --
-        # see the FIX 1 note above `drops` for why that distinction matters.
+        # Name exactly what was dropped rather than staying silent about it;
+        # report both configurations' counts when they differ, one when only
+        # one configuration lost any rows. Worded as runs actually used out
+        # of runs considered (row counts), not accepted counts -- see the
+        # note above `drops` for why that distinction matters.
         pieces = [f"{n_used} of {n_considered} runs considered ({a})" for a, n_used, n_considered in drops]
         pair["basis_note"] = (
             "computed on " + " and ".join(pieces) + " where both the token count "