cctally 1.114.0 → 1.115.0

package/bin/_lib_pricing.py

@@ -92,7 +92,12 @@ def _chip_for_model(name: str) -> str:
 # fingerprint a store recorded and refuses a write from an older process. That
 # comparison is day-granular by construction, so two revisions sharing a date
 # compare equal and the older process is authorized to write.
-PRICING_SNAPSHOT_DATE = "2026-10-07"
+#
+# A sync of this date or of either table also changes the dynamic-SQL shape
+# pinned in `bin/_lib_detector_access_registry.py`, so its registry test fails
+# until the affected pins are re-pinned through the reviewed procedure in that
+# module's docstring. Bulk regeneration of the pins alone is not acceptance.
+PRICING_SNAPSHOT_DATE = "2026-10-14"
 PRICING_STALENESS_DAYS = 60  # release pre-flight WARNs past this age
 
 
@@ -700,7 +705,7 @@ CLAUDE_MODEL_PRICING: dict[str, dict[str, Any]] = {
         "input_cost_per_token": 2e-06,
         "output_cost_per_token": 1e-05,
         "cache_creation_input_token_cost": 2.5e-06,
-        "cache_read_input_token_cost": 2e-07,
+        "cache_read_input_token_cost": 1e-07,
     },
 }
 

package/bin/_lib_quarantine.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""The one parser of tests/quarantine.json, the reviewed flaky-test list (spec 4.3).
+
+Stdlib only. An entry's `id` takes one of two forms:
+
+* a pytest node id, `tests/<file>.py::<node>` (a prefix: pytest's --deselect
+  semantics cover every parametrization of a listed function);
+* a harness case, `harness:<harness-name>::<case>`, where `<harness-name>` is
+  the `NAME` of `bin/cctally-NAME-test` and `<case>` is one scenario of that
+  harness's own case inventory (`bin/cctally-NAME-test --list-cases`).
+
+`bin/cctally-test-all`, `bin/_lib_merge_gate.py` and the quick gate read the
+list through this module; the scheduled CI quarantine leg calls its CLI. An
+absent list quarantines nothing (the public mirror may carry none); a list
+that exists but cannot be read raises QuarantineError, never "nothing listed".
+
+CLI (exit 0, or 2 on an unreadable list or bad usage):
+    python3 bin/_lib_quarantine.py pytest-ids
+    python3 bin/_lib_quarantine.py harness-cases <harness>
+"""
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+import re
+import subprocess
+import sys
+
+LIST_PATH = Path('tests') / 'quarantine.json'
+FIELDS = ('id', 'evidence', 'invariant', 'issue', 'replacement', 'reviewBy')
+PYTEST_ID = re.compile(r'tests/[^:\s]+\.py::\S+')
+HARNESS_ID = re.compile(r'harness:([a-z0-9][a-z0-9-]*)::([A-Za-z0-9][A-Za-z0-9_.-]*)')
+
+
+class QuarantineError(ValueError):
+    """tests/quarantine.json exists but is not a list this parser can apply."""
+
+
+@dataclass(frozen=True)
+class Entry:
+    id: str
+    kind: str                 # 'pytest' or 'harness'
+    harness: str | None       # the harness name for a harness case
+    case: str | None          # the case name for a harness case
+    fields: dict
+
+
+def parse_id(entry_id: str) -> tuple[str, str | None, str | None]:
+    """(kind, harness, case) of one id; QuarantineError for any other form."""
+    if not isinstance(entry_id, str):
+        raise QuarantineError(f'an entry id must be a string, not {entry_id!r}')
+    if PYTEST_ID.fullmatch(entry_id):
+        return 'pytest', None, None
+    match = HARNESS_ID.fullmatch(entry_id)
+    if match:
+        return 'harness', match.group(1), match.group(2)
+    raise QuarantineError(
+        f'{entry_id!r} is neither a pytest node id (tests/<file>.py::<node>) '
+        'nor a harness case (harness:<harness>::<case>)')
+
+
+def parse(doc) -> list[Entry]:
+    if not isinstance(doc, list):
+        raise QuarantineError('expected a JSON list of entries')
+    entries = []
+    for item in doc:
+        if not isinstance(item, dict):
+            raise QuarantineError(f'expected each entry to be an object, not {item!r}')
+        kind, harness, case = parse_id(item.get('id'))
+        entries.append(Entry(item['id'], kind, harness, case, dict(item)))
+    ids = [e.id for e in entries]
+    if len(set(ids)) != len(ids):
+        raise QuarantineError('duplicate entry ids: ' + ', '.join(
+            sorted({i for i in ids if ids.count(i) > 1})))
+    return entries
+
+
+def load_path(path: Path) -> list[Entry]:
+    path = Path(path)
+    if not path.is_file():
+        return []
+    try:
+        doc = json.loads(path.read_text(encoding='utf-8'))
+    except (OSError, ValueError) as exc:
+        raise QuarantineError(f'{path}: {exc}') from None
+    return parse(doc)
+
+
+def load(repo: Path) -> list[Entry]:
+    return load_path(Path(repo) / LIST_PATH)
+
+
+def pytest_ids(entries) -> list[str]:
+    return [e.id for e in entries if e.kind == 'pytest']
+
+
+def harness_cases(entries, harness: str) -> list[str]:
+    return [e.case for e in entries if e.kind == 'harness' and e.harness == harness]
+
+
+def harness_inventory(repo: Path, harness: str, *, timeout: float = 60) -> list[str]:
+    """The case names `bin/cctally-<harness>-test --list-cases` prints.
+
+    QuarantineError when the harness does not exist or has no case inventory:
+    a harness case that cannot be validated against the harness is not
+    quarantinable."""
+    script = Path(repo) / 'bin' / f'cctally-{harness}-test'
+    if not script.is_file():
+        raise QuarantineError(f'harness:{harness}: bin/cctally-{harness}-test does not exist')
+    proc = subprocess.run([str(script), '--list-cases'], cwd=repo, capture_output=True,
+                          text=True, timeout=timeout)
+    if proc.returncode != 0:
+        raise QuarantineError(f'harness:{harness}: --list-cases exited {proc.returncode}: '
+                              + (proc.stderr or proc.stdout).strip()[-400:])
+    return [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+
+
+def validate_harness_cases(repo: Path, entries) -> None:
+    """Each harness case names an existing harness and a case in its inventory."""
+    inventories: dict[str, list[str]] = {}
+    for entry in entries:
+        if entry.kind != 'harness':
+            continue
+        if entry.harness not in inventories:
+            inventories[entry.harness] = harness_inventory(repo, entry.harness)
+        if entry.case not in inventories[entry.harness]:
+            raise QuarantineError(f'{entry.id}: no case {entry.case!r} in the '
+                                  f'{entry.harness} harness inventory')
+
+
+def main(argv=None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    repo = Path(__file__).resolve().parents[1]
+    if len(argv) >= 2 and argv[0] == '--repo':
+        repo, argv = Path(argv[1]), argv[2:]
+    try:
+        if argv == ['pytest-ids']:
+            out = pytest_ids(load(repo))
+        elif len(argv) == 2 and argv[0] == 'harness-cases':
+            out = harness_cases(load(repo), argv[1])
+        else:
+            print('usage: _lib_quarantine.py [--repo DIR] pytest-ids | harness-cases <harness>',
+                  file=sys.stderr)
+            return 2
+    except QuarantineError as exc:
+        print(f'quarantine: {exc}', file=sys.stderr)
+        return 2
+    for item in out:
+        print(item)
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

package/bin/_lib_quota_calibration.py

@@ -62,6 +62,10 @@ class ApplyRejection(str, enum.Enum):
 
     UNSUPPORTED_COMPOSITION = "unsupported-composition"
     EMPTY_POPULATION = "no-local-history"
+    #: The requested interval, or an entry of the population, lies outside
+    #: the regime's own coefficient era (#978 spec 4.6). Units from another
+    #: era are never divided by this regime's units-per-point.
+    UNVALIDATED_COEFFICIENT_ERA = "unvalidated-coefficient-era"
 
 
 @dataclasses.dataclass(frozen=True)
@@ -88,6 +92,9 @@ class ValidatedRegime:
     class_shares: dict
     family_radius: "float | None"
     class_radius: "float | None"
+    #: The id of the coefficient era the regime was fitted in, always a
+    #: member of `qm.COEFFICIENT_ERAS` (#978).
+    coefficient_era: str
     qualifications: tuple = ()
 
 
@@ -196,6 +203,13 @@ def validate_regime(raw, *, account_key, expected_fingerprint,
     if isinstance(revision, bool) or not isinstance(revision, int) \
             or revision != expected_revision:
         return RegimeRejection.REVISION
+    # #978 spec 4.5: under the current constants a regime names the
+    # coefficient era it was fitted in. Missing or unknown is malformed, never
+    # a guess at an era; a regime from an older build has already been
+    # reported above as a fingerprint mismatch.
+    era = qm.era_by_id(raw.get("coefficientEra"))
+    if era is None:
+        return RegimeRejection.MALFORMED
 
     point = raw.get("unitsPerPoint")
     if not _finite(point) or point <= 0.0:
@@ -256,31 +270,42 @@ def validate_regime(raw, *, account_key, expected_fingerprint,
         class_shares=class_shares,
         family_radius=family_radius,
         class_radius=class_radius,
+        coefficient_era=era.id,
         qualifications=marks,
     )
 
 
-def population_units(entries) -> float:
+def population_units(entries, *, era) -> float:
     """Summed weighted quota units over the general-meter entries.
 
     The same filter `_cctally_quota_model.analyse_account` applies to the
     current week: an entry whose family does not drain the general weekly
     meter contributes nothing, and one whose cache-write split is unknown is
-    skipped rather than priced at zero.
+    skipped rather than priced at zero. Every entry is weighted with `era`,
+    the regime's own coefficient era (#978).
+
+    An entry `era` does not cover raises `CoefficientEraMismatch`, as the
+    kernel's population functions do (#978 spec 4.2, invariant 5): skipping
+    it would divide part of the population by the regime's budget and report
+    the result as the whole.
     """
     total = 0.0
     for entry in entries:
         if qm.family_participation(qm.normalize_family(entry.model)) \
                 != "general":
             continue
-        units = qm.weighted_units(entry)
-        if units is None:
+        weighed = qm.weigh_entry(entry, era)
+        if weighed.cause == qm.ERA_UNAVAILABLE:
+            raise qm.CoefficientEraMismatch(
+                f"entry.at {entry.at.isoformat()} lies outside coefficient "
+                f"era {era.id!r}")
+        if weighed.units is None:
             continue
-        total += units
+        total += weighed.units
     return total
 
 
-def apply_regime(regime: ValidatedRegime, entries
+def apply_regime(regime: ValidatedRegime, entries, *, interval
                  ) -> "AppliedQuota | ApplyRejection":
     """Modelled consumption for `entries` under `regime`.
 
@@ -288,8 +313,28 @@ def apply_regime(regime: ValidatedRegime, entries
     status, because that status describes S1's fit population and this one is
     the consumer's. The arithmetic afterwards reproduces the kernel's, so a
     consumer never re-derives the inversion by hand.
+
+    `interval` is the half-open `[start, end)` the caller models, which a
+    consumer extrapolating over a whole week must pass as that week (#978
+    spec 4.6). Two independent checks run before any aggregation: the
+    interval must lie inside the regime's coefficient era, and so must every
+    entry. The interval check is not implied by the entry check — a week
+    starting before the era whose retained entries all fall after its start
+    is in-era entry by entry, yet modelling the whole week is forbidden.
     """
-    aggregated = qm.aggregate_composition(entries)
+    era = qm.era_by_id(regime.coefficient_era)
+    if era is None:
+        return ApplyRejection.UNVALIDATED_COEFFICIENT_ERA
+    start, end = interval
+    qm.require_aware(start, "interval.start")
+    qm.require_aware(end, "interval.end")
+    era_start, era_end = qm.era_bounds(era)
+    if start < era_start or (era_end is not None and end > era_end):
+        return ApplyRejection.UNVALIDATED_COEFFICIENT_ERA
+    entries = list(entries)
+    if any(not qm.era_contains(era, entry.at) for entry in entries):
+        return ApplyRejection.UNVALIDATED_COEFFICIENT_ERA
+    aggregated = qm.aggregate_composition(entries, era=era)
     if aggregated is None:
         return ApplyRejection.EMPTY_POPULATION
     family_shares, class_shares = aggregated
@@ -298,7 +343,7 @@ def apply_regime(regime: ValidatedRegime, entries
                            regime.class_shares, regime.class_radius):
         return ApplyRejection.UNSUPPORTED_COMPOSITION
 
-    units = population_units(entries)
+    units = population_units(entries, era=era)
     if not _finite(units) or units < 0.0:
         return ApplyRejection.EMPTY_POPULATION
 

package/bin/_lib_quota_copy.py

@@ -70,7 +70,8 @@ _LONG_FORM: dict = {
         "the models in use sit outside the mix the calibration was fitted "
         "over",
     "unvalidated-coefficient-era":
-        "this window predates the token weights the model is validated for",
+        "this window is not inside a single coefficient era the token "
+        "weights are validated for",
     "stale":
         "the stored calibration was fitted under different constants, so it "
         "no longer describes this build",