loopmath 0.2.5__tar.gz → 0.2.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmath
-Version: 0.2.5
+Version: 0.2.6
 Summary: Plan agent workflows, record how they went, and learn from your own Claude Code and Codex logs
 Author: QKV Labs
 License-Expression: MIT
@@ -118,7 +118,7 @@ loopmath run start --rec REC --choice goal --base-commit SHA --json      # the h
 loopmath run record --run RUN --session UUID --verified tests=pass --json  # costs from the logs, the outcome, the receipt
 ```
 
-With `--run`, a session that started before the run counts from the run's start (a Codex session counts whole). Give `--since TS` and `--until TS` when the task's work began or ended at another time; `--since` before `run start` moves the run's start back. When no commit is found after the base commit, the record says where it looked; pass `--commit SHA`. `loopmath run sessions` lists the recent Claude Code and Codex sessions in this folder with their ids, for `--session ID`. Outside a Claude Code tool shell, `--session self` uses the one Claude Code session in this folder active in the last 10 minutes.
+With `--run`, a session that started before the run counts from the run's start; a Codex session counts the usage it logged inside the window: each reading's increase at the reading's time, a reading on either edge included. 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:
 

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

@@ -80,7 +80,7 @@ loopmath run start --rec REC --choice goal --base-commit SHA --json      # the h
 loopmath run record --run RUN --session UUID --verified tests=pass --json  # costs from the logs, the outcome, the receipt
 ```
 
-With `--run`, a session that started before the run counts from the run's start (a Codex session counts whole). Give `--since TS` and `--until TS` when the task's work began or ended at another time; `--since` before `run start` moves the run's start back. When no commit is found after the base commit, the record says where it looked; pass `--commit SHA`. `loopmath run sessions` lists the recent Claude Code and Codex sessions in this folder with their ids, for `--session ID`. Outside a Claude Code tool shell, `--session self` uses the one Claude Code session in this folder active in the last 10 minutes.
+With `--run`, a session that started before the run counts from the run's start; a Codex session counts the usage it logged inside the window: each reading's increase at the reading's time, a reading on either edge included. 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:
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "loopmath"
-version = "0.2.5"
+version = "0.2.6"
 description = "Plan agent workflows, record how they went, and learn from your own Claude Code and Codex logs"
 readme = "README.md"
 license = "MIT"

{loopmath-0.2.5 → loopmath-0.2.6}/src/loopmath/__init__.py

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

{loopmath-0.2.5 → loopmath-0.2.6}/src/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-0.2.5 → loopmath-0.2.6}/src/loopmath/adapters/paseo.py

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

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

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

{loopmath-0.2.5 → loopmath-0.2.6}/src/loopmath/belief/design.py

@@ -36,7 +36,7 @@ HEURISTIC_COST_WEIGHT = 0.7  # spec 04 section 2 and D27: allocated (heuristic)
 USER_SOURCES = ("live", "backlog", "history", "user", "orchestrator", "onboard", "habit", "")
 HORIZON_NODES = ("horizon:timebox", "horizon:log2h")  # fixed terms of a timeboxed run (spec 04 section 1)
 RQ1_EXT = "dev.loopmath.rq1"  # loopmath-exp's ext key; its horizon_s is the fallback for older RQ1 runs
-# 0.2.1 (F5, spec 04 section 1): in the cost and tokens rows of a timeboxed task the terms a timebox caps (effort
+# 0.2.1 (spec 04 section 1): in the cost and tokens rows of a timeboxed task the terms a timebox caps (effort
 # and shape) enter at this value, not 1. Set from the RQ1 2 h runs: open-ended effort terms gave max over low x2.64
 # (solo luna) and x2.23 (solo sol) against x1.34 and x1.27 observed; ln 1.34 / ln 2.64 = ln 1.27 / ln 2.23 = 0.30.
 TIMEBOX_EFFORT_COST = 0.3
@@ -465,7 +465,7 @@ def source_label(doc: dict) -> str:
     share = ext.get("dev.loopmath.share")
     if isinstance(share, dict):
         # the importer writes `source` and `task.org` as `shared:<org_hash>` already: never prefix twice. With no
-        # org at all the source is `shared`, the name `fit --without shared` takes (0.2.3, 22X review N1)
+        # org at all the source is `shared`, the name `fit --without shared` takes (0.2.3)
         org = (share.get("source") or share.get("org") or share.get("org_hash") or (run.get("task") or {}).get("org")
                or "")
         name = str(org).removeprefix("shared:")
@@ -640,7 +640,7 @@ def _ocp_fields(cost: dict) -> dict[str, float]:
 
 def _price_split(split: dict, table) -> float | None:
     """Dollars for `{model: OCP token fields}`, each model at its own current rate, summed; None when any
-    part is unpriced or unlabelled (lane 02's `price.price_model_tokens`)."""
+    part is unpriced or unlabelled (`price.price_model_tokens`)."""
     from ..price import price_model_tokens
 
     usd = price_model_tokens(split, table).get("usd")
@@ -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
 
@@ -786,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-0.2.5 → loopmath-0.2.6}/src/loopmath/belief/fit.py

@@ -4,7 +4,7 @@ Spec 04 section 4. `fit()` reads finished OCP v0.3 runs (the store, the shipped
 shared imports), builds the rows of every head, sets the level scales by empirical Bayes,
 and writes `fits/<fit>.partial/{state.npz, meta.json, design.json}`, renamed to
 `fits/<fit>/` when complete; `fits/latest` then points at it. A non-blocking `flock` on
-`fits/.fit.lock` stops two fits running together (lane 7's trigger has its own job lock on
+`fits/.fit.lock` stops two fits running together (the store's fit trigger has its own job lock on
 `fits/.lock`, so the two never wait on each other).
 """
 
@@ -136,7 +136,7 @@ def _nothing_to_fit(no_prior: bool, without: tuple[str, ...], dropped: dict[str,
 # ---------------------------------------------------------------- reading documents
 
 def store_docs(home: Path) -> Iterator[dict]:
-    """Finished run documents in the store, through lane 7's reader (it decides what is finished)."""
+    """Finished run documents in the store, through the store's reader (it decides what is finished)."""
     from ..store.home import Store
 
     yield from Store(home).finished_docs()
@@ -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-0.2.5 → loopmath-0.2.6}/src/loopmath/belief/forest.py

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

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

@@ -1,4 +1,4 @@
-"""The price offset on the cost head (spec 04 section 2, 0.2.2, lane 22C).
+"""The price offset on the cost head (spec 04 section 2, 0.2.2).
 
 A model's run cost moves with its list price. Every cost row of a model version `m` (not the tokens, gate,
 success or score rows) carries the fixed term `price:offset` with the value

{loopmath-0.2.5 → loopmath-0.2.6}/src/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-0.2.6/src/loopmath/builder/__init__.py

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

{loopmath-0.2.5 → loopmath-0.2.6}/src/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-0.2.5 → loopmath-0.2.6}/src/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-0.2.5 → loopmath-0.2.6}/src/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-0.2.5 → loopmath-0.2.6}/src/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,9 +87,8 @@ 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)
@@ -114,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
@@ -145,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.
@@ -210,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 "

{loopmath-0.2.5 → loopmath-0.2.6}/src/loopmath/e0/arms.py

@@ -84,34 +84,31 @@ def session_arm(session: dict) -> str | None:
     return f"{model}·{effort}"
 
 
-# Project-family collapse: worktree lanes fold into families (design doc
-# section 2). Verified against the corpus inventory on 2026-08-30:
-# - trailing digits are lane numbers (bots-c1..c6, project-fable2..3)
-# - -remediation / -vX.Y-recovery are herdr-dagr recovery lanes
-# - pitauri-t1..t7 ("pitauri-teams" sibling set per census section 7) and
-#   pitauri-ft1..ft5 ("pit-followups") carry task-name suffixes, e.g.
-#   pitauri-t1-settings, so they collapse by prefix, not by trailing digit
-# - -fable / -sol suffixes are paired model lanes of the same remediation
-#   project (interactions / interactions-fable3 / interactions-sol3 and five
-#   more base names under herdr-dagr-remediation); they collapse to the base
-#   so the deliberate fable-vs-sol A/B lanes land in shared cells
-_LANE_RE = re.compile(r"(-remediation.*|-v[\d.]+-recovery.*|\d+$)")
-_MODEL_LANE_RE = re.compile(r"-(fable|sol)$")
-_PITAURI_TEAM_RE = re.compile(r"^pitauri-t\d")
-_PITAURI_FT_RE = re.compile(r"^pitauri-ft\d")
+# Project-family collapse: worktree copies fold into families (design doc
+# section 2):
+# - trailing digits are copy numbers (app-c1..c6, app2..3)
+# - -remediation / -vX.Y-recovery are recovery copies
+# - task sibling sets `<base>-t<N>` and follow-up sets `<base>-ft<N>` may carry
+#   task-name suffixes (app-t1-settings), so they collapse by prefix, not by
+#   trailing digit: to `<base>-teams` and `<base>-ft`
+# - -fable / -sol suffixes are paired model copies of the same remediation
+#   project (app / app-fable3 / app-sol3); they collapse to the base so the
+#   deliberate fable-vs-sol A/B copies land in shared cells
+_COPY_RE = re.compile(r"(-remediation.*|-v[\d.]+-recovery.*|\d+$)")
+_MODEL_COPY_RE = re.compile(r"-(fable|sol)$")
+_SIBLING_RE = re.compile(r"^(?P<base>.+?)-(?P<kind>ft|t)\d+(?:-|$)")
 
 
 def project_family(project: str | None) -> str:
     if not project:
         return "unknown"
     base = project.rstrip("/").split("/")[-1]
-    if _PITAURI_FT_RE.match(base):
-        return "pitauri-ft"
-    if _PITAURI_TEAM_RE.match(base):
-        return "pitauri-teams"
-    base = _LANE_RE.sub("", base)
-    base = _MODEL_LANE_RE.sub("", base)
-    if base.startswith("video-"):  # video-analyzer <-> video-orchestrator
+    sibling = _SIBLING_RE.match(base)
+    if sibling:
+        return sibling["base"] + ("-ft" if sibling["kind"] == "ft" else "-teams")
+    base = _COPY_RE.sub("", base)
+    base = _MODEL_COPY_RE.sub("", base)
+    if base.startswith("video-"):  # every video-* project is one family
         base = "video"
     return base or "unknown"
 

{loopmath-0.2.5 → loopmath-0.2.6}/src/loopmath/e0/figures.py

@@ -307,7 +307,7 @@ def write_report(
         "",
         f"- real main sessions: {len(segments['main'])}",
         (
-            f"- harvest fleet stubs, Aug 23-24 (primary_model null AND "
+            f"- fleet stubs (primary_model null AND "
             f"error_events >= 1): {len(segments['fleet_stubs'])}"
         ),
         (