cctally 1.115.0 → 1.116.0

package/bin/_cctally_journal_repair.py

@@ -75,7 +75,7 @@ def _read_prefix(high_water):
     malformed = 0
     prior_high_water = None
     cutover_captured = _journal._CUTOVER_UNSEEN
-    hasher = _lib_journal_router.PrefixHashAccumulator()
+    hasher = _journal._new_prefix_hasher()
     # #825/#832 (spec 5.3): admission is resolved within this one pass and
     # applied after it, before selection or normalization. An excluded record
     # — an old process's repair acknowledgement or correction batch included —
@@ -87,7 +87,8 @@ def _read_prefix(high_water):
         None,
         high_water,
         segments,
-        on_segment=lambda name: hasher.begin_segment(name, prior_high_water),
+        on_segment=lambda name, size: hasher.begin_segment(
+            name, prior_high_water, size=size),
         on_bytes=hasher.extend,
     ):
         record = _lib_journal.decode_line(raw)
@@ -122,11 +123,12 @@ def _read_prefix(high_water):
         coordinates.append((segment, offset))
         prior_high_water = record_end
     prefix_hash = hasher.digest_at(high_water)
-    # The accumulator buffers the segment it is reading — 410 MB on the
-    # maintainer's journal — so it is dropped the moment its pass ends, before
-    # the normalization loop below, exactly as `rebuild_stats_index` drops it.
-    # It is dropped before the raise too, so a malformed prefix does not pin the
-    # buffer on the traceback while the exception unwinds.
+    # The accumulator streams its hash and retains no segment bytes (#997
+    # D12), but it still holds hash states, its registered boundaries and the
+    # segment opener, and nothing after the pass needs them. It is dropped the
+    # moment its pass ends, before the normalization loop below, exactly as
+    # `rebuild_stats_index` drops it, and before the raise too, so a malformed
+    # prefix does not pin it on the traceback while the exception unwinds.
     hasher = None
     if malformed:
         raise _lib_journal.JournalProtocolError(

package/bin/_cctally_oauth_samples.py

@@ -0,0 +1,280 @@
+"""Provider-sample projection glue (#797/#823/#840 spec 4.3, D8 and D9).
+
+`claude_oauth_samples` (stats epoch 1019) holds one row per ADMITTED Claude
+api observation carrying a valid `oauth_request_started_at`, materialized
+from the raw journal record by :func:`project_sample` — the one projection
+implementation every derivation path shares:
+
+* live ingest and the scratch replays (plain `db rederive`, the derivation-
+  completion step) through `_cctally_record._pipeline_claude_usage`, which
+  projects every admitted reading before reset/credit detection and the
+  snapshot fold decision, so equal readings that the fold deduplicates still
+  each produce a sample, and neither the five-hour MAX adjustment nor credit
+  suppression or retirement touches a sample;
+* ordinary and correction rebuilds (`_rebuild_stats_index_locked`), which are
+  apply-only and never run the pipeline, through :class:`RebuildProjector`
+  offered every admitted record of the rebuild's single read pass.
+
+Reviewed weekly decisions (`claude_weekly_observation_decision`, its `_v2`
+successor) are projected beside it into `claude_weekly_observation_decisions`
+by the op fold applier :func:`apply_weekly_observation_decision_op`, latest
+decision per observation winning in journal order, so the weekly eligibility
+of a sample is resolved at READ time and a later decision rewrites no sample
+row. A `hold` makes only the WEEKLY sample ineligible; a later effective
+`accept` restores it; five-hour samples are never excluded by a weekly
+decision. (The schema-3 `retract` projects each retraction as an ordinary
+`hold` in `weekly_axis_decisions`, so it needs nothing further here.)
+
+Rows are retained: nothing in this work prunes the table. The read is exact-
+window (spec D9) and an unavailable projection raises
+:class:`ProjectionUnavailable` rather than answering "no sample".
+"""
+from __future__ import annotations
+
+import sqlite3
+from typing import Literal
+
+import _lib_oauth_samples
+
+SAMPLES_TABLE = "claude_oauth_samples"
+DECISIONS_TABLE = "claude_weekly_observation_decisions"
+#: The reviewed weekly decision kinds and the payload key holding each schema
+#: version's decision list.
+_DECISION_LISTS = {1: "decisions", 2: "weekly_axis_decisions",
+                   3: "weekly_axis_decisions"}
+_DISPOSITIONS = frozenset(("hold", "accept"))
+
+_INSERT = (
+    "INSERT OR IGNORE INTO claude_oauth_samples (account_key, observation_id,"
+    " requested_at_utc, captured_at_utc, weekly_percent, weekly_resets_at_utc,"
+    " five_hour_percent, five_hour_resets_at_utc, five_hour_window_key)"
+    " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+)
+_COLUMNS = (
+    "s.account_key, s.observation_id, s.requested_at_utc, s.captured_at_utc,"
+    " s.weekly_percent, s.weekly_resets_at_utc, s.five_hour_percent,"
+    " s.five_hour_resets_at_utc, s.five_hour_window_key"
+)
+_READ_WEEKLY = (
+    f"SELECT {_COLUMNS} FROM claude_oauth_samples AS s"
+    " WHERE s.account_key = ? AND s.weekly_resets_at_utc = ?"
+    "   AND s.requested_at_utc > ? AND s.weekly_percent IS NOT NULL"
+    "   AND unixepoch(s.captured_at_utc) < unixepoch(s.weekly_resets_at_utc)"
+    "   AND NOT EXISTS (SELECT 1 FROM claude_weekly_observation_decisions AS d"
+    "                    WHERE d.observation_id = s.observation_id"
+    "                      AND d.disposition = 'hold')"
+    " ORDER BY s.requested_at_utc, s.observation_id"
+)
+_READ_FIVE_HOUR = (
+    f"SELECT {_COLUMNS} FROM claude_oauth_samples AS s"
+    " WHERE s.account_key = ? AND s.five_hour_window_key = ?"
+    "   AND s.requested_at_utc > ? AND s.five_hour_percent IS NOT NULL"
+    "   AND unixepoch(s.captured_at_utc)"
+    "       < MIN(unixepoch(s.five_hour_resets_at_utc), s.five_hour_window_key)"
+    " ORDER BY s.requested_at_utc, s.observation_id"
+)
+_UPSERT_DECISION = (
+    "INSERT INTO claude_weekly_observation_decisions (observation_id,"
+    " disposition, decision_op_id) VALUES (?, ?, ?)"
+    " ON CONFLICT(observation_id) DO UPDATE SET"
+    " disposition = excluded.disposition,"
+    " decision_op_id = excluded.decision_op_id"
+)
+
+
+class ProjectionUnavailable(RuntimeError):
+    """The samples projection cannot be read on this connection (absent,
+    older index shape): a classification that needs it is unavailable,
+    never "no proof"."""
+
+
+def sample_from_record(rec) -> "_lib_oauth_samples.OAuthSample | None":
+    """The sample of one journal record, or None. Only a current-revision
+    (`wpr: 2`) Claude usage observation from a recording source can carry a
+    sample — the same records `_pipeline_claude_usage` derives — so no key is
+    ever honoured on a historical or previous-release record."""
+    if not isinstance(rec, dict) or rec.get("t") != "obs":
+        return None
+    payload = rec.get("payload")
+    if (not isinstance(payload, dict)
+            or _lib_oauth_samples.REQUEST_STARTED_KEY not in payload
+            or rec.get("provider") != "claude"):
+        return None
+    if "resets_at" not in payload or "weekly_percent" not in payload:
+        return None
+    import _cctally_record
+    import _lib_account_protocol
+    import _lib_accounts
+    if rec.get("src") not in _cctally_record._CLAUDE_OBS_SRCS:
+        return None
+    if not _lib_account_protocol.has_current_revision(rec):
+        return None
+    return _lib_oauth_samples.sample_from_observation(
+        payload,
+        account_key=rec.get("account") or _lib_accounts.UNATTRIBUTED,
+        observation_id=rec.get("id"),
+        captured_at_utc=payload.get("captured_at"),
+    )
+
+
+def project_sample(conn, sample: "_lib_oauth_samples.OAuthSample") -> None:
+    """Materialize ``sample`` on ``conn`` (the caller's transaction).
+    Idempotent: an observation id is a content id, so a replay of the same
+    record inserts nothing."""
+    conn.execute(_INSERT, sample.row())
+
+
+def project_record(conn, rec) -> None:
+    """Project ``rec``'s sample when it carries one. The caller has already
+    admitted ``rec``."""
+    sample = sample_from_record(rec)
+    if sample is not None:
+        project_sample(conn, sample)
+
+
+class RebuildProjector:
+    """The apply-only rebuild's leg of the projection: its single read pass
+    offers every admitted record, and samples are projected into the scratch
+    index in bounded batches (one transaction each), so the pass never holds
+    the whole sample population in memory."""
+
+    BATCH = 2048
+
+    def __init__(self, conn) -> None:
+        self._conn = conn
+        self._pending: list = []
+        self.projected = 0
+
+    def offer(self, rec) -> None:
+        sample = sample_from_record(rec)
+        if sample is None:
+            return
+        self._pending.append(sample)
+        if len(self._pending) >= self.BATCH:
+            self.flush()
+
+    def flush(self) -> None:
+        if not self._pending:
+            return
+        conn = self._conn
+        conn.execute("BEGIN IMMEDIATE")
+        try:
+            for sample in self._pending:
+                project_sample(conn, sample)
+            conn.commit()
+        except BaseException:
+            conn.rollback()
+            raise
+        self.projected += len(self._pending)
+        self._pending = []
+
+
+def apply_weekly_observation_decision_op(conn, record) -> None:
+    """Fold applier for a reviewed weekly decision op: each well-formed
+    ``{observationId, disposition}`` entry becomes the observation's
+    effective decision (latest op wins, in journal order). Malformed entries
+    are skipped here; `db rederive` validates every retained decision op and
+    refuses a malformed one."""
+    payload = record.get("payload") if isinstance(record, dict) else None
+    if not isinstance(payload, dict):
+        return
+    version = payload.get("schema_version")
+    key = _DECISION_LISTS.get(version) if type(version) is int else None
+    decisions = payload.get(key) if key is not None else None
+    if not isinstance(decisions, list):
+        return
+    op_id = record.get("id")
+    if not isinstance(op_id, str):
+        return
+    for item in decisions:
+        if not isinstance(item, dict):
+            continue
+        observation_id = item.get("observationId")
+        disposition = item.get("disposition")
+        if (isinstance(observation_id, str) and observation_id
+                and disposition in _DISPOSITIONS):
+            conn.execute(_UPSERT_DECISION,
+                         (observation_id, disposition, op_id))
+
+
+def read_samples(conn, *, account_key: str,
+                 axis: Literal["weekly", "five_hour"],
+                 window: "str | int",
+                 requested_after_utc: str,
+                 ) -> "tuple[_lib_oauth_samples.OAuthSample, ...]":
+    """The account's samples of exactly one authoritative window whose `q` is
+    strictly after ``requested_after_utc`` and whose response was captured
+    before that window's reset, ordered by `q`.
+
+    ``window`` is the weekly reset (an epoch or a tz-aware ISO instant, raw or
+    normalized: the nearest-hour normalization is the identity) for
+    ``"weekly"``, and the canonical five-hour window key for
+    ``"five_hour"``. The weekly read excludes an observation whose effective
+    reviewed weekly decision is `hold`; the five-hour read never does. The
+    capture bound uses the sample's own window (for five hours, the earlier
+    of its raw reset and its window key); the caller still compares against
+    its member's advertised reset. Raises :class:`ProjectionUnavailable`
+    when the projection cannot be read."""
+    if not isinstance(account_key, str) or not account_key:
+        raise ValueError("read_samples requires an exact account")
+    after = _lib_oauth_samples.canonical_instant(requested_after_utc)
+    if axis == "weekly":
+        sql = _READ_WEEKLY
+        key = _lib_oauth_samples.weekly_window(window)
+    elif axis == "five_hour":
+        if type(window) is not int:
+            raise ValueError("a five-hour window is its canonical int key")
+        sql = _READ_FIVE_HOUR
+        key = window
+    else:
+        raise ValueError(f"unknown sample axis: {axis!r}")
+    try:
+        rows = conn.execute(sql, (account_key, key, after)).fetchall()
+    except sqlite3.OperationalError as exc:
+        raise ProjectionUnavailable(str(exc)) from exc
+    return tuple(_lib_oauth_samples.OAuthSample(*row) for row in rows)
+
+
+_READ_ONE = (
+    f"SELECT {_COLUMNS} FROM claude_oauth_samples AS s"
+    " WHERE s.account_key = ? AND s.observation_id = ?"
+)
+
+
+def sample_for_observation(conn, *, account_key: str, observation_id
+                           ) -> "_lib_oauth_samples.OAuthSample | None":
+    """The account's admitted sample of exactly one observation, or None when
+    that observation is not an admitted sample (or the projection cannot be
+    read). #797 spec 4.4: a five-hour credit's causal facts name the
+    observations it was armed and baselined from; their request instants
+    and RAW values are read here, never from the clamped snapshot column."""
+    if not isinstance(account_key, str) or not account_key or observation_id is None:
+        return None
+    try:
+        row = conn.execute(_READ_ONE, (account_key, str(observation_id))).fetchone()
+    except sqlite3.Error:
+        return None
+    return None if row is None else _lib_oauth_samples.OAuthSample(*row)
+
+
+def projection_covered(conn, *, account_key: str) -> bool:
+    """Whether ``conn`` holds a complete samples projection for
+    ``account_key``: the index is at this binary's epoch with both
+    projection tables. The projection commits in the same transaction as
+    the journal cursor on every path, so a current index covers every
+    admitted observation up to its cursor for every account; anything else
+    (an older or newer index shape, a missing table, an unreadable
+    connection) is uncovered."""
+    if not isinstance(account_key, str) or not account_key:
+        return False
+    import _cctally_core
+    try:
+        epoch = conn.execute("PRAGMA user_version").fetchone()[0]
+        if epoch != _cctally_core.STATS_INDEX_EPOCH:
+            return False
+        names = {str(row[0]) for row in conn.execute(
+            "SELECT name FROM sqlite_schema WHERE type = 'table'"
+            " AND name IN (?, ?)", (SAMPLES_TABLE, DECISIONS_TABLE))}
+    except sqlite3.Error:
+        return False
+    return names == {SAMPLES_TABLE, DECISIONS_TABLE}

package/bin/_cctally_parser.py

@@ -1849,6 +1849,11 @@ def _build_record_usage_parser(subparsers, name, *, help_text, xref=None):
                           fi
                           cctally record-usage $record_args &
                       fi
+
+                    Note: this direct recipe cannot tell an idle session's cached
+                    reading from a fresh one after a credit, so an idle session can
+                    record a value the credit already retired. `cctally statusline`
+                    can tell them apart; prefer it as the status line command.
                     """
                 ),
     )

package/bin/_cctally_quarantine.py

@@ -380,16 +380,26 @@ class QuarantineFold:
                         kind=TRIGGER_LEGACY_SPOOL,
                         reason=str(payload.get("reason") or "changed"),
                         segment=segment, offset=offset, at=rec.get("at"))
-            elif kind == _lib_account_protocol.CUTOVER_OP_KIND:
+            elif kind in (_lib_account_protocol.CUTOVER_OP_KIND,
+                          _lib_account_protocol.REVISION_OP_KIND):
                 # Spec revision 5 (section 7, *Before the initial cutover*):
                 # a cutover that could not complete its legacy spool
                 # inventory records the uncertainty in itself, and is the
                 # same unresolved-marker trigger an `inventory-incomplete`
-                # op is, at the cutover's own position.
+                # op is, at the cutover's own position. #797/#823/#840
+                # (spec 4.6 B2): so is a revision-2 boundary whose expanded
+                # inventory could not complete.
+                expected_id = (
+                    _lib_account_protocol.CUTOVER_OP_ID
+                    if kind == _lib_account_protocol.CUTOVER_OP_KIND
+                    else _lib_account_protocol.REVISION_OP_ID)
                 if (_lib_account_protocol.is_stamped(rec)
-                        and rec.get("id") == _lib_account_protocol.CUTOVER_OP_ID
+                        and rec.get("id") == expected_id
                         and payload.get("legacySpoolInventoryFailure")
-                        is not None):
+                        is not None
+                        # A revision op continuing an open failure episode
+                        # adds no trigger: the episode already has one.
+                        and payload.get("inventoryEpisode") is None):
                     self.state.on_trigger(
                         kind=TRIGGER_LEGACY_SPOOL,
                         reason=_lib_account_protocol.INVENTORY_INCOMPLETE_REASON,

package/bin/_cctally_quota.py

@@ -2063,6 +2063,63 @@ def _apply_codex_window_attribution_overlay(
     ))
 
 
+class _QuotaLoadValues:
+    """The values one `load_codex_quota_observations` call shares (#997 D17).
+
+    A full load materializes every retained observation (266 k on the
+    maintainer's copy, about 2.3 KB each), and every row brought its own copy
+    of each repeated text value, its own parsed reset instants and its own
+    `QuotaWindowIdentity`. Within one call this keeps one object per distinct
+    text value, one parsed instant per distinct stored reset text, and one
+    identity per distinct tuple of ALL its fields. `limit_id` and
+    `limit_name` are outside the identity's equality, so sharing by equality
+    alone would hand one observation another's labels; the tuple includes them
+    (with their types, so a hand-written ``1`` and ``1.0`` stay apart). Every
+    shared value is immutable, so values, equality and order are unchanged.
+    """
+
+    __slots__ = ("_texts", "_resets", "_identities")
+
+    def __init__(self) -> None:
+        self._texts: dict = {}
+        self._resets: dict = {}
+        self._identities: dict = {}
+
+    def text(self, value):
+        """``value``'s shared object; a non-string is returned unchanged."""
+        if type(value) is not str:
+            return value
+        return self._texts.setdefault(value, value)
+
+    def reset(self, text: str, label: str) -> dt.datetime:
+        """`_parse_utc(text, label)`, parsed once per distinct text."""
+        parsed = self._resets.get(text)
+        if parsed is None:
+            parsed = self._resets[text] = _parse_utc(text, label)
+        return parsed
+
+    def identity(self, *, source, source_root_key, account_key,
+                 logical_limit_key, observed_slot, window_minutes, limit_id,
+                 limit_name) -> QuotaWindowIdentity:
+        key = (source, source_root_key, account_key, logical_limit_key,
+               observed_slot, type(window_minutes), window_minutes,
+               type(limit_id), limit_id, type(limit_name), limit_name)
+        identity = self._identities.get(key)
+        if identity is None:
+            text = self.text
+            identity = self._identities[key] = QuotaWindowIdentity(
+                source=text(source),
+                source_root_key=text(source_root_key),
+                account_key=text(account_key),
+                logical_limit_key=text(logical_limit_key),
+                observed_slot=text(observed_slot),
+                window_minutes=window_minutes,
+                limit_id=text(limit_id),
+                limit_name=text(limit_name),
+            )
+        return identity
+
+
 def load_codex_quota_observations(
     *,
     source_root_keys: Iterable[str] | None = None,
@@ -2463,6 +2520,9 @@ def load_codex_quota_observations(
             row_source = _iter_shard_rows(conn, shards)
         result: list[QuotaObservation] = []
         signature_tuples: dict[str, dict[str, list[tuple[object, ...]]]] = {}
+        # #997 D17: repeated values are shared within this call.
+        values = _QuotaLoadValues()
+        text = values.text
         for row in row_source:
             if not _codex_quota_required_text_present(
                 row[name] for name in _CODEX_QUOTA_REQUIRED_TEXT
@@ -2498,7 +2558,7 @@ def load_codex_quota_observations(
                     str(raw_account) if raw_account not in (None, "")
                     else _lib_accounts.UNATTRIBUTED
                 )
-                identity = QuotaWindowIdentity(
+                identity = values.identity(
                     source=str(row["source"]),
                     source_root_key=str(row["source_root_key"]),
                     account_key=account_key,
@@ -2512,16 +2572,18 @@ def load_codex_quota_observations(
                     identity=identity,
                     captured_at=_parse_utc(str(row["captured_at_utc"]), "captured_at_utc"),
                     used_percent=float(row["used_percent"]),
-                    resets_at=_parse_utc(str(row["resets_at_utc"]), "resets_at_utc"),
-                    source_path=str(row["source_path"]),
+                    resets_at=values.reset(
+                        str(row["resets_at_utc"]), "resets_at_utc"),
+                    source_path=text(str(row["source_path"])),
                     line_offset=int(row["line_offset"]),
-                    plan_type=row["plan_type"],
-                    individual_limit_json=row["individual_limit_json"],
-                    reached_type=row["reached_type"],
+                    plan_type=text(row["plan_type"]),
+                    individual_limit_json=text(row["individual_limit_json"]),
+                    reached_type=text(row["reached_type"]),
                     canonical_resets_at=(
                         None if row["canonical_resets_at_utc"] in (None, "")
-                        else _parse_utc(str(row["canonical_resets_at_utc"]),
-                                        "canonical_resets_at_utc")
+                        else values.reset(
+                            str(row["canonical_resets_at_utc"]),
+                            "canonical_resets_at_utc")
                     ),
                 )
             except (TypeError, ValueError, OverflowError):

package/bin/_cctally_quota_model.py

@@ -1211,9 +1211,22 @@ def stored_regimes(state: dict, account_key) -> list:
 # breaks the digest, so it reads as legacy too.
 _REGIME_WRITER_KEY = "wpg"
 _REGIME_WRITER_DIGEST_KEY = "wpgDigest"
+# #797/#823/#840 spec 4.6 B5: recovery also requires revision-specific
+# provenance. A revision-1 process (the previous release) writes a regime
+# with a verifying `wpg` stamp, so that stamp alone cannot tell its
+# transitions from this binary's. Every regime this binary writes also
+# carries `wpr` and a revision-specific digest over its content without any
+# of the four writer keys; a previous-release in-place `update()` keeps
+# `wpr` but cannot recompute that digest.
+_REGIME_REVISION_KEY = "wpr"
+_REGIME_REVISION_DIGEST_KEY = "wprDigest"
+_REGIME_WRITER_KEYS = (_REGIME_WRITER_KEY, _REGIME_WRITER_DIGEST_KEY,
+                       _REGIME_REVISION_KEY, _REGIME_REVISION_DIGEST_KEY)
 
 
 def _regime_content_digest(regime: dict) -> str:
+    # The revision-1 digest, unchanged: over everything but the two `wpg`
+    # keys, so the previous release still verifies this binary's stamp.
     core = {k: v for k, v in regime.items()
             if k not in (_REGIME_WRITER_KEY, _REGIME_WRITER_DIGEST_KEY)}
     data = json.dumps(core, sort_keys=True, separators=(",", ":"),
@@ -1221,11 +1234,24 @@ def _regime_content_digest(regime: dict) -> str:
     return "sha256:" + hashlib.sha256(data.encode("utf-8")).hexdigest()
 
 
+def _regime_revision_digest(regime: dict) -> str:
+    import _lib_account_protocol
+    core = {k: v for k, v in regime.items() if k not in _REGIME_WRITER_KEYS}
+    data = json.dumps(
+        {"revision": _lib_account_protocol.PROTOCOL_REVISION,
+         "regime": core},
+        sort_keys=True, separators=(",", ":"), ensure_ascii=False,
+        default=str)
+    return "sha256:" + hashlib.sha256(data.encode("utf-8")).hexdigest()
+
+
 def stamp_regime(regime: dict) -> dict:
-    """``regime`` stamped as written by the current protocol generation."""
+    """``regime`` stamped as written by the current protocol generation and
+    revision."""
     import _lib_account_protocol
-    out = {k: v for k, v in regime.items()
-           if k not in (_REGIME_WRITER_KEY, _REGIME_WRITER_DIGEST_KEY)}
+    out = {k: v for k, v in regime.items() if k not in _REGIME_WRITER_KEYS}
+    out[_REGIME_REVISION_KEY] = _lib_account_protocol.PROTOCOL_REVISION
+    out[_REGIME_REVISION_DIGEST_KEY] = _regime_revision_digest(out)
     out[_REGIME_WRITER_KEY] = _lib_account_protocol.PROTOCOL_GENERATION
     out[_REGIME_WRITER_DIGEST_KEY] = _regime_content_digest(out)
     return out
@@ -1237,7 +1263,12 @@ def regime_writer_is_current(regime) -> bool:
             and regime.get(_REGIME_WRITER_KEY)
             == _lib_account_protocol.PROTOCOL_GENERATION
             and regime.get(_REGIME_WRITER_DIGEST_KEY)
-            == _regime_content_digest(regime))
+            == _regime_content_digest(regime)
+            and _lib_account_protocol.has_current_revision(
+                {_lib_account_protocol.REVISION_KEY:
+                 regime.get(_REGIME_REVISION_KEY)})
+            and regime.get(_REGIME_REVISION_DIGEST_KEY)
+            == _regime_revision_digest(regime))
 
 
 def stamp_current_writes(stored: dict, reduced: dict, account_key) -> dict: