loopmath 0.2.4__tar.gz → 0.2.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmath
-Version: 0.2.4
+Version: 0.2.5
 Summary: Plan agent workflows, record how they went, and learn from your own Claude Code and Codex logs
 Author: QKV Labs
 License-Expression: MIT
@@ -241,7 +241,7 @@ The store is `~/.loopmath`. Set `LOOPMATH_HOME` or pass `--home` to put it elsew
 - signals, receipts and fits;
 - your config and your workflows;
 - the views you write;
-- the caches: the log parse cache, and the folder where `fit --full` compiles its model (when that compile fails, it also leaves the C code it tried in the system temp folder and prints where).
+- the caches: the log parse cache, and the folder where `fit --full` compiles its model (when that compile fails, it also leaves the C code it tried in a `pytensor_compilation_error_*` file in the system temp folder and prints where).
 
 Do not edit the store by hand; use the commands. `loopmath verify-receipts` checks the receipts in your store; give a file to verify a research receipt ledger instead.
 
@@ -260,7 +260,7 @@ loopmath analyze                 # cost per accepted run from the last 14 days o
 loopmath graph --workspace NAME --format html --out graph.html
 ```
 
-`analyze` reads `~/.claude/projects` and `~/.codex/sessions`. It grades the outcome evidence it finds, prices known models, and prints cost per accepted run with an 80% band. It also lists what it could not use and why; when no workflow configuration has enough runs to compare, it says how many runs it read and what kept each out, and what to try (`--min-n`, `--grading`). `loopmath analyze --json` prints the same as one JSON object, and `--home PATH` keeps its parse cache in that store.
+`analyze` reads `~/.claude/projects` and `~/.codex/sessions`. It grades the outcome evidence it finds, prices known models, and prints cost per accepted run with an 80% band. It also lists what it could not use and why; when no workflow configuration is eligible to compare, it names the largest comparison exclusion, its count, and what to try. `loopmath analyze --json` prints the same as one JSON object, and `--home PATH` keeps its parse cache in that store.
 
 `loopmath prices` lists the packaged prices with the source of each. A rate marked "rate not confirmed" is a best public-price guess, and every dollar figure priced with one says so.
 

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

@@ -203,7 +203,7 @@ The store is `~/.loopmath`. Set `LOOPMATH_HOME` or pass `--home` to put it elsew
 - signals, receipts and fits;
 - your config and your workflows;
 - the views you write;
-- the caches: the log parse cache, and the folder where `fit --full` compiles its model (when that compile fails, it also leaves the C code it tried in the system temp folder and prints where).
+- the caches: the log parse cache, and the folder where `fit --full` compiles its model (when that compile fails, it also leaves the C code it tried in a `pytensor_compilation_error_*` file in the system temp folder and prints where).
 
 Do not edit the store by hand; use the commands. `loopmath verify-receipts` checks the receipts in your store; give a file to verify a research receipt ledger instead.
 
@@ -222,7 +222,7 @@ loopmath analyze                 # cost per accepted run from the last 14 days o
 loopmath graph --workspace NAME --format html --out graph.html
 ```
 
-`analyze` reads `~/.claude/projects` and `~/.codex/sessions`. It grades the outcome evidence it finds, prices known models, and prints cost per accepted run with an 80% band. It also lists what it could not use and why; when no workflow configuration has enough runs to compare, it says how many runs it read and what kept each out, and what to try (`--min-n`, `--grading`). `loopmath analyze --json` prints the same as one JSON object, and `--home PATH` keeps its parse cache in that store.
+`analyze` reads `~/.claude/projects` and `~/.codex/sessions`. It grades the outcome evidence it finds, prices known models, and prints cost per accepted run with an 80% band. It also lists what it could not use and why; when no workflow configuration is eligible to compare, it names the largest comparison exclusion, its count, and what to try. `loopmath analyze --json` prints the same as one JSON object, and `--home PATH` keeps its parse cache in that store.
 
 `loopmath prices` lists the packaged prices with the source of each. A rate marked "rate not confirmed" is a best public-price guess, and every dollar figure priced with one says so.
 

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

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

{loopmath-0.2.4 → loopmath-0.2.5}/src/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-0.2.4 → loopmath-0.2.5}/src/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-0.2.4 → loopmath-0.2.5}/src/loopmath/belief/design.py

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

{loopmath-0.2.4 → loopmath-0.2.5}/src/loopmath/cli_support.py

@@ -100,19 +100,9 @@ def _extremes_ratio(df, result, price_mod) -> dict:
     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"]

{loopmath-0.2.4 → loopmath-0.2.5}/src/loopmath/graph/html_common.py

@@ -86,7 +86,7 @@ const App = (() => {
         const small = Number(v.toFixed(digits));
         if (small >= 10 ** (1 - digits)) digits -= 1;  // 0.00096 rounds up to $0.001, still one digit
         if (small < 0.01) return '$' + small.toFixed(digits);
-        v = small;  // 0.0096 rounds up to a cent
+        return '$' + small.toFixed(2);  // 0.0096 rounds up to $0.01
       }
       return '$' + v.toFixed(v < 0.1 ? 3 : 2);
     },

{loopmath-0.2.4 → loopmath-0.2.5}/src/loopmath/ocp/contractv3.py

@@ -31,9 +31,9 @@ Mapping summary (contract v3 -> OCP 0.1):
   task.policy          -> node.ext["dev.dagr.policy"] (typed, inert)
   attempt.locator      -> dropped (volatile runtime address)
   attempt.liveness     -> dropped (live-view data, not telemetry)
-  costs                -> ABSENT: contract v3 carries no token usage.
-                          This is the known gap; a v3 amendment or the
-                          orchestrator plugin must supply attempt.cost.
+  graph export ext     -> per-attempt costs and full model/harness/effort,
+                          joined by task and attempt IDs. Plain contracts
+                          without this telemetry keep costs absent.
 """
 
 from __future__ import annotations
@@ -146,6 +146,9 @@ def convert(doc):
         raise ValueError("input is not a dagr contract run document")
     # The contract's own version key is 'dagr' (the pre-rename product name).
     contract_version = doc.get("dagr", 1)
+    from .graph_contract import telemetry
+
+    graph_records = telemetry(doc)
 
     run_in = doc["run"]
     run = {"id": run_in.get("id", "unknown-run")}
@@ -159,6 +162,9 @@ def convert(doc):
         "source_contract": f"dagr/{contract_version}",
     }
     put(producer, "emitted_at", doc.get("generated_at"))
+    if graph_records is not None:
+        producer["capabilities"] = {"groups": True, "events": True, "edges_dep": True,
+                                    "cost_usd": True, "cost_tokens": True, "outcome_evidence": True}
 
     groups = []
     for prj in doc.get("projects", []) or []:
@@ -190,7 +196,10 @@ def convert(doc):
                 edges.append({"from": src, "to": tid, "kind": "dep"})
 
         for att in task.get("attempts", []) or []:
-            attempts.append(convert_attempt(tid, att))
+            converted = convert_attempt(tid, att)
+            if graph_records is not None:
+                converted.update(graph_records[tid, converted["id"]])
+            attempts.append(converted)
 
     events = []
     for ev in doc.get("events", []) or []:

loopmath-0.2.5/src/loopmath/ocp/graph_contract.py

@@ -0,0 +1,86 @@
+"""Read the per-attempt telemetry carried by loopmath's graph contract export."""
+from __future__ import annotations
+
+import copy
+import math
+
+KEYS = ("dev.loopmath.graph", "dev.dagr.graph")
+TOKEN_FIELDS = ("input_tokens", "cached_input_tokens", "cache_creation_tokens", "cache_creation_5m_tokens",
+                "cache_creation_1h_tokens", "output_tokens", "reasoning_tokens", "requests")
+
+
+def extension(obj: dict) -> dict | None:
+    ext = obj.get("ext") or {}
+    if not isinstance(ext, dict):
+        return None
+    found = [ext[key] for key in KEYS if key in ext]
+    if not found:
+        return None
+    if any(not isinstance(value, dict) for value in found) or any(value != found[0] for value in found[1:]):
+        raise ValueError("graph extension is malformed or has conflicting namespaces")
+    return found[0]
+
+
+def _cost(value: object) -> dict:
+    if not isinstance(value, dict):
+        raise ValueError("graph cost must be an object")
+    for key in (*TOKEN_FIELDS, "usd"):
+        if key not in value:
+            continue
+        number = value[key]
+        if (isinstance(number, bool) or not isinstance(number, (int, float)) or not math.isfinite(number)
+                or number < 0 or (key != "usd" and not isinstance(number, int))):
+            raise ValueError(f"graph cost {key} must be a finite nonnegative {'number' if key == 'usd' else 'integer'}")
+    for key, kind in (("basis", str), ("ext", dict), ("tariff", dict)):
+        if key in value and not isinstance(value[key], kind):
+            raise ValueError(f"graph cost {key} has the wrong type")
+    buckets = ("cache_creation_5m_tokens", "cache_creation_1h_tokens")
+    if all(key in value for key in (*buckets, "cache_creation_tokens")):
+        if sum(value[key] for key in buckets) != value["cache_creation_tokens"]:
+            raise ValueError("graph cost cache retention buckets disagree with their total")
+    return copy.deepcopy(value)
+
+
+def telemetry(doc: dict) -> dict[tuple[str, str], dict] | None:
+    """Return exact task/attempt records; None leaves an ordinary contract unchanged.
+
+    Identical duplicate representations are harmless. Conflicting or dangling
+    references are errors, never a reason to choose or allocate an amount.
+    """
+    graph = extension(doc)
+    if graph is None:
+        return None
+    records = {}
+    for task in doc.get("tasks") or []:
+        tid = task.get("id", "?")
+        attempts = task.get("attempts") or []
+        meta = extension(task) or {}
+        settings = {key: meta[key] for key in ("model", "harness", "effort") if key in meta and meta[key] is not None}
+        if settings and len(attempts) != 1:
+            raise ValueError(f"graph task {tid!r} has ambiguous task-level model metadata")
+        if "model" in settings and (not isinstance(settings["model"], dict)
+                                    or not isinstance(settings["model"].get("raw"), str)):
+            raise ValueError("graph model metadata must be a model reference")
+        for key in ("harness", "effort"):
+            if key in settings and not isinstance(settings[key], str):
+                raise ValueError(f"graph {key} metadata must be a string")
+        for attempt in attempts:
+            aid = attempt.get("id", f"{tid}.a{attempt.get('n', '?')}")
+            if not isinstance(tid, str) or not isinstance(aid, str) or (tid, aid) in records:
+                raise ValueError("graph task/attempt identity is invalid or duplicated")
+            records[tid, aid] = copy.deepcopy(settings)
+    costs = graph.get("costs", [])
+    if not isinstance(costs, list):
+        raise ValueError("graph costs must be an array")
+    for row in costs:
+        if not isinstance(row, dict) or not isinstance(row.get("task"), str) or not isinstance(row.get("attempt"), str):
+            raise ValueError("graph cost needs task and attempt identities")
+        pair = (row["task"], row["attempt"])
+        if pair not in records:
+            raise ValueError(f"graph cost references an unknown task/attempt pair: {pair!r}")
+        cost = _cost(row.get("cost"))
+        old = records[pair].get("cost")
+        if old is not None and old != cost:
+            raise ValueError(f"graph cost records conflict for {pair!r}")
+        records[pair]["cost"] = cost
+    return records

loopmath-0.2.5/src/loopmath/ocp/membership.py

@@ -0,0 +1,69 @@
+"""Read saved import membership without guessing roles or repairing explicit references."""
+from __future__ import annotations
+
+from typing import Any
+
+_ADAPTERS = {"pi", "opencode", "omp", "otel-genai", "paseo", "orca", "bb", "atrium"}
+_MIGRATED_FROM = {"0.1", "0.2", "dagr/1", "dagr/2", "dagr/3"}
+_COST_FIELDS = ("usd", "input_tokens", "cached_input_tokens", "cache_creation_tokens", "output_tokens")
+
+
+def imported_node_map(doc: dict) -> dict:
+    """Saved node map only for recognized migration or adapter/graph provenance."""
+    run = doc.get("run") or {}
+    ext = run.get("ext") or {}
+    marker = ext.get("dev.loopmath.migration") if isinstance(ext, dict) else None
+    migrated = (isinstance(marker, dict) and isinstance(marker.get("from"), str)
+                and marker["from"] in _MIGRATED_FROM)
+    producer = doc.get("producer") or {}
+    name = producer.get("name") if isinstance(producer, dict) else None
+    adapter = isinstance(name, str) and name in {
+        f"{prefix}/adapter-{a}" for prefix in ("loopmath", "dagr") for a in _ADAPTERS}
+    top_ext = doc.get("ext") or {}
+    graph = name in ("loopmath", "dagr") and isinstance(top_ext, dict) and any(
+        isinstance(top_ext.get(key), dict) for key in ("dev.loopmath.graph", "dev.dagr.graph"))
+    config = run.get("configuration") or {}
+    mapping = config.get("node_vertex") if isinstance(config, dict) else None
+    return mapping if (migrated or adapter or graph) and isinstance(mapping, dict) else {}
+
+
+def model_work(attempt: dict) -> bool:
+    """The membership counterpart of the fitter's costless, model-free check rule."""
+    setting = attempt.get("setting") or {}
+    if attempt.get("model") or (isinstance(setting, dict) and setting.get("model")):
+        return True
+    cost = attempt.get("cost") or {}
+    return isinstance(cost, dict) and any(
+        isinstance(cost.get(key), (int, float)) and cost[key] > 0 for key in _COST_FIELDS)
+
+
+def materialize(doc: dict[str, Any]) -> None:
+    """Fill absent vertices from a validated saved map, on the migration's private copy."""
+    mapping = imported_node_map(doc)
+    if not mapping:
+        return
+    config = (doc.get("run") or {}).get("configuration") or {}
+    workflow = config.get("workflow") or {}
+    settings = config.get("settings") or {}
+    if not isinstance(workflow, dict) or not isinstance(settings, dict):
+        return
+    pieces = {p.get("id") for p in workflow.get("pieces") or [] if isinstance(p, dict) and isinstance(p.get("id"), str)}
+    by_node: dict[str, list[dict]] = {}
+    for attempt in doc.get("attempts") if isinstance(doc.get("attempts"), list) else []:
+        if isinstance(attempt, dict) and isinstance(attempt.get("node"), str):
+            by_node.setdefault(attempt["node"], []).append(attempt)
+    for node in doc.get("nodes") if isinstance(doc.get("nodes"), list) else []:
+        if not isinstance(node, dict) or "vertex" in node:
+            continue
+        nid = node.get("id")
+        piece = mapping.get(nid) if isinstance(nid, str) else None
+        if not isinstance(piece, str) or piece not in pieces or piece not in settings:
+            continue
+        attempts = by_node.get(nid, [])
+        # A shared node must not give a model-free check (or an explicit empty
+        # vertex) membership indirectly through node.vertex.
+        eligible = [a for a in attempts if "vertex" not in a and model_work(a)]
+        if eligible and len(eligible) == len(attempts):
+            node["vertex"] = piece
+        for attempt in eligible:
+            attempt["vertex"] = piece

{loopmath-0.2.4 → loopmath-0.2.5}/src/loopmath/ocp/migrate.py

@@ -11,7 +11,8 @@ only when absent:
 - `run.task` from `run.labels` (`task`, `type`, `repo`) when any is present:
   `id` from the `task` label, else the run id; `labeled_by` is
   `{how: inferred, tier: heuristic}`;
-- `node.vertex` from its attempts' `role.value` when they agree on one value;
+- absent model-attempt vertices from the configuration's saved node mapping,
+  then `node.vertex` from unanimous `role.value` when still absent;
 - `run.provenance = {kind: logged, chooser: habit}`;
 - `run.configuration = {source: habit}`, plus the inferred workflow and
   settings when `infer` returns one (lane 04's `loopmath.workflows.infer`),
@@ -106,6 +107,22 @@ def migrate_doc(doc: dict[str, Any], *, infer: Infer | None = infer_configuratio
             task["labeled_by"] = {"how": "inferred", "tier": "heuristic"}
             run["task"] = task
 
+    run.setdefault("provenance", {"kind": "logged", "chooser": "habit"})
+    if "configuration" not in run:
+        inferred = infer(source if origin else out) if infer is not None else None
+        if inferred is not None:
+            configuration, confidence = inferred
+            configuration = dict(configuration, source="habit")
+            configuration.setdefault("ext", {})[INFERRED_KEY] = {"confidence": confidence, "tier": "heuristic"}
+            run["configuration"] = configuration
+        else:
+            run["configuration"] = {"source": "habit"}
+
+    # The exact inference map takes precedence over a role word generated
+    # below, while vertices explicitly present in the input remain untouched.
+    from .membership import materialize
+
+    materialize(out)
     roles: dict[str, set[str]] = {}
     for attempt in _list(out.get("attempts")):
         if not isinstance(attempt, dict):
@@ -119,14 +136,4 @@ def migrate_doc(doc: dict[str, Any], *, infer: Infer | None = infer_configuratio
         if isinstance(nid, str) and "vertex" not in node and len(roles.get(nid, ())) == 1:
             node["vertex"] = next(iter(roles[nid]))
 
-    run.setdefault("provenance", {"kind": "logged", "chooser": "habit"})
-    if "configuration" not in run:
-        inferred = infer(source if origin else out) if infer is not None else None
-        if inferred is not None:
-            configuration, confidence = inferred
-            configuration = dict(configuration, source="habit")
-            configuration.setdefault("ext", {})[INFERRED_KEY] = {"confidence": confidence, "tier": "heuristic"}
-            run["configuration"] = configuration
-        else:
-            run["configuration"] = {"source": "habit"}
     return out

loopmath-0.2.5/src/loopmath/report/eligibility.py

@@ -0,0 +1,45 @@
+"""Explain comparison eligibility using the surface's existing exclusion counts."""
+from collections import Counter
+
+
+COMPARISON = (
+    "configuration below min_overlap_cells",
+    "run's task-mix cell not shared with another configuration",
+    "configuration below min_n",
+)
+EARLY = ("unknown acceptance", "no usable cost value", "no model label")
+
+
+def unavailable_lines(surface: dict, n_configs: int = 0) -> list[str]:
+    if n_configs == 1:
+        return ["only one workflow configuration is eligible, so there is nothing to compare"]
+    counts = Counter()
+    for item in surface.get("exclusions") or []:
+        counts[item.get("reason")] += max(0, int(item.get("n") or 0))
+    candidates = sum(counts[r] for r in COMPARISON) + int(surface.get("n_rows_used") or 0)
+    choices = [r for r in COMPARISON if counts[r] > 0]
+    population = f"{candidates:,} runs with known outcomes, usable cost and model labels"
+    if not choices:
+        choices = [r for r in EARLY if counts[r] > 0]
+        population = f"{int(surface.get('n_rows') or sum(counts.values())):,} runs read"
+    if not choices:
+        return ["no workflow configuration is eligible, so there is nothing to compare"]
+    # A tie follows the fixed presentation order above, never input ordering.
+    reason = max(choices, key=counts.__getitem__)
+    description, remedy = {
+        COMPARISON[0]: ("their configurations lack enough shared task-mix cells (overlap)",
+                        "read more comparable history with shared task-mix cells (--all or a larger --since)"),
+        COMPARISON[1]: ("their task-mix cells are not shared with another configuration",
+                        "read more comparable history with shared task-mix cells (--all or a larger --since)"),
+        COMPARISON[2]: (f"their configurations fall below the minimum run count (--min-n {surface.get('min_n', 5)})",
+                        "read more history (--all or a larger --since), or lower the minimum (--min-n 3)"),
+        EARLY[0]: ("they have unknown acceptance outcomes", "see which evidence counted as acceptance (--grading)"),
+        EARLY[1]: ("they have no usable cost", "check missing prices or token counts for the selected cost basis"),
+        EARLY[2]: ("they have no model label", "check that the imported history records model names"),
+    }[reason]
+    lines = [f"no workflow configuration is eligible; the largest exclusion is {counts[reason]:,} of {population}: {description}"]
+    early = [f"{counts[r]:,} {r}" for r in EARLY if counts[r]]
+    if reason in COMPARISON and early:
+        lines.append("before comparison: " + ", ".join(early))
+    lines.append("to get a table: " + remedy)
+    return lines

{loopmath-0.2.4 → loopmath-0.2.5}/src/loopmath/report/html.py

@@ -14,6 +14,8 @@ from pathlib import Path
 from typing import Any, Iterable
 
 from .terminal import PRIVACY_LINE, beat3_exclusions
+from .eligibility import unavailable_lines
+from ..surface_presentation import shown_band_support_note
 
 
 _STYLE = """
@@ -130,7 +132,7 @@ def _configuration_table(surface: dict[str, Any]) -> str:
         key=_sort_value,
     )
     if not rows:
-        return '<p class="note">No configurations met the minimum run count.</p>'
+        return "".join(f'<p class="note">{escape(line)}</p>' for line in unavailable_lines(surface))
 
     scale_low, scale_high = _band_positions(rows)
     span = scale_high - scale_low
@@ -237,8 +239,9 @@ def render(
     exclusions = "".join(f"<li>{escape(line.strip())}</li>" for line in exclusion_lines)
     notices = [
         surface.get(key)
-        for key in ("tier_note", "overlap_caveat", "band_note", "band_support_note")
+        for key in ("tier_note", "overlap_caveat", "band_note")
     ]
+    notices.append(shown_band_support_note(surface))
     notices.extend(price_warnings or [])
     notes_html = "".join(f'<p class="note">{escape(str(note))}</p>' for note in notices if note)
     coverage_text = coverage_line or "No grading coverage available."

{loopmath-0.2.4 → loopmath-0.2.5}/src/loopmath/report/terminal.py

@@ -137,24 +137,9 @@ PRIVACY_LINE = "Local only. Nothing uploaded."
 
 def _no_configuration_lines(surface: dict) -> list[str]:
     """Why the table is empty, from the surface's own exclusion counts, and what to try."""
-    min_n = surface.get("min_n")
-    counts = {e.get("reason"): int(e.get("n") or 0) for e in surface.get("exclusions") or []}
-    n_rows = surface.get("n_rows")
-    head = (f"  no workflow configuration has {min_n} runs with a known outcome (the minimum, --min-n)"
-            if min_n else "  no configurations met the minimum run count")
-    lines = [head]
-    parts = []
-    for reason, words in (("unknown acceptance", "had no acceptance evidence in the logs"),
-                          ("configuration below min_n", "are in configurations with fewer runs than that"),
-                          ("no usable cost value", "had no usable cost"),
-                          ("no model label", "had no model name")):
-        if counts.get(reason):
-            parts.append(f"{_fmt_int(counts[reason])} {words}")
-    if parts and n_rows:
-        lines.append(f"  of {_fmt_int(n_rows)} runs read, " + ", ".join(parts))
-    lines.append("  to get a table: read more history (--all, or a larger --since), lower the minimum "
-                 "(--min-n 3), or see which evidence counted as acceptance (--grading)")
-    return lines
+    from .eligibility import unavailable_lines
+
+    return ["  " + line for line in unavailable_lines(surface)]
 
 
 def beat2_configurations(

{loopmath-0.2.4 → loopmath-0.2.5}/src/loopmath/store/fitjob.py

@@ -113,7 +113,8 @@ def spawn_fit(home: Path, *, no_prior: bool | None = None, without: tuple[str, .
 
     With neither `no_prior` nor `without` given (the store's own refits) the fit leaves out what the
     latest fit left out, decided when it runs; `fit --background` passes its flags, even empty ones."""
-    home = Path(home)
+    # Anchor paths in the caller before the child changes its working directory.
+    home = Path(home).expanduser().resolve()
     fits = _fits(home)
     inherit = no_prior is None and without is None
     opts = _opts(bool(no_prior), without or (), full, inherit=inherit)
@@ -132,6 +133,9 @@ def spawn_fit(home: Path, *, no_prior: bool | None = None, without: tuple[str, .
     if full:
         cmd.append("--full")
     env = dict(os.environ)
+    env["LOOPMATH_HOME"] = str(home)
+    if env.get("LOOPMATH_CACHE_DIR"):
+        env["LOOPMATH_CACHE_DIR"] = str(Path(env["LOOPMATH_CACHE_DIR"]).expanduser().resolve())
     root = _package_root()
     env["PYTHONPATH"] = root + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
     log_path = fits / "fit.log"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmath
-Version: 0.2.4
+Version: 0.2.5
 Summary: Plan agent workflows, record how they went, and learn from your own Claude Code and Codex logs
 Author: QKV Labs
 License-Expression: MIT
@@ -241,7 +241,7 @@ The store is `~/.loopmath`. Set `LOOPMATH_HOME` or pass `--home` to put it elsew
 - signals, receipts and fits;
 - your config and your workflows;
 - the views you write;
-- the caches: the log parse cache, and the folder where `fit --full` compiles its model (when that compile fails, it also leaves the C code it tried in the system temp folder and prints where).
+- the caches: the log parse cache, and the folder where `fit --full` compiles its model (when that compile fails, it also leaves the C code it tried in a `pytensor_compilation_error_*` file in the system temp folder and prints where).
 
 Do not edit the store by hand; use the commands. `loopmath verify-receipts` checks the receipts in your store; give a file to verify a research receipt ledger instead.
 
@@ -260,7 +260,7 @@ loopmath analyze                 # cost per accepted run from the last 14 days o
 loopmath graph --workspace NAME --format html --out graph.html
 ```
 
-`analyze` reads `~/.claude/projects` and `~/.codex/sessions`. It grades the outcome evidence it finds, prices known models, and prints cost per accepted run with an 80% band. It also lists what it could not use and why; when no workflow configuration has enough runs to compare, it says how many runs it read and what kept each out, and what to try (`--min-n`, `--grading`). `loopmath analyze --json` prints the same as one JSON object, and `--home PATH` keeps its parse cache in that store.
+`analyze` reads `~/.claude/projects` and `~/.codex/sessions`. It grades the outcome evidence it finds, prices known models, and prints cost per accepted run with an 80% band. It also lists what it could not use and why; when no workflow configuration is eligible to compare, it names the largest comparison exclusion, its count, and what to try. `loopmath analyze --json` prints the same as one JSON object, and `--home PATH` keeps its parse cache in that store.
 
 `loopmath prices` lists the packaged prices with the source of each. A rate marked "rate not confirmed" is a best public-price guess, and every dollar figure priced with one says so.
 

{loopmath-0.2.4 → loopmath-0.2.5}/src/loopmath.egg-info/SOURCES.txt

@@ -180,6 +180,8 @@ src/loopmath/ocp/commands.py
 src/loopmath/ocp/conformance.py
 src/loopmath/ocp/contractv3.py
 src/loopmath/ocp/emit.py
+src/loopmath/ocp/graph_contract.py
+src/loopmath/ocp/membership.py
 src/loopmath/ocp/migrate.py
 src/loopmath/ocp/version.py
 src/loopmath/ocp/schema/ocp-v0.2.schema.json
@@ -223,6 +225,7 @@ src/loopmath/recommend/search.py
 src/loopmath/recommend/stats.py
 src/loopmath/recommend/storeread.py
 src/loopmath/report/__init__.py
+src/loopmath/report/eligibility.py
 src/loopmath/report/html.py
 src/loopmath/report/terminal.py
 src/loopmath/report/terminal_exclusions.py
@@ -361,6 +364,7 @@ tests/test_preview_script.py
 tests/test_price.py
 tests/test_receipts.py
 tests/test_release_paths.py
+tests/test_report_eligibility.py
 tests/test_research_cli.py
 tests/test_runfile_privacy_n1b.py
 tests/test_scoring.py