cctally 1.118.0 → 1.118.2

package/bin/_cctally_dashboard.py

@@ -6871,9 +6871,14 @@ def build_cached_claude_range_aggregates_from_capture(
     try:
         if "projects" in failures:
             raise failures["projects"]
+        # #1059: observing memos, so a spelling first resolved on an
+        # incremental tick is registered for the identity sweep too. A flip
+        # bumps the generation in `base`, which forces the cold branch below
+        # with a fresh memo in the same build.
+        _sc = _cctally()._load_sibling("_lib_snapshot_cache")
         if incremental:
             project_mut = copy.deepcopy(prior["project_mut"])
-            resolver_cache = dict(prior["resolver_cache"])
+            resolver_cache = _sc.observing_project_memo(prior["resolver_cache"])
             for row, priced_entry in zip(rows, prepared):
                 _fold_projects_entry(
                     project_mut,
@@ -6883,7 +6888,8 @@ def build_cached_claude_range_aggregates_from_capture(
                     priced_entry=priced_entry,
                 )
         else:
-            resolver_cache = {}
+            _sc.note_project_work("rangeFullRefolds")
+            resolver_cache = _sc.observing_project_memo()
             project_mut = fold_projects_over_range(
                 rows,
                 resolver_cache=resolver_cache,
@@ -7080,6 +7086,7 @@ def _assemble_projects_via_cache(
     cw_end: "dt.datetime",
     cur_max_id: int,
     cur_max_seq: int,
+    resolver_cache: "dict | None" = None,
 ) -> "tuple[dict, dict, dict]":
     """Flag-ON assembly (#269 §14 Win 2): recompute only the CURRENT week each
     warm tick; serve CLOSED weeks from the per-(project, week) cache on a hit and
@@ -7097,10 +7104,17 @@ def _assemble_projects_via_cache(
     tick's ``MAX(mutation_seq)`` (the #270 §8 delta watermark, so an id-stable
     in-place finalization is caught). The accumulator is single-writer here (this
     runs only on the sync-thread ``use_projects_env_cache=True`` path).
+
+    #1059: the memo is an OBSERVING memo (``resolver_cache`` when the caller
+    supplies one), because every resolution here can be retained — by the
+    current-week accumulator, a cold seed or a closed-week miss — and a
+    retained resolution the identity sweep cannot see would keep a stale
+    grouping until a restart.
     """
     c = _cctally()
     sc = c._load_sibling("_lib_snapshot_cache")
-    resolver_cache: dict = {}
+    if resolver_cache is None:
+        resolver_cache = sc.observing_project_memo()
     buckets: dict = {}
     total_cost_by_week: dict = {}
     key_by_bucket: dict = {}
@@ -7196,6 +7210,9 @@ def _assemble_projects_via_cache(
             if hit is not None:
                 week_buckets, week_total = hit
             else:
+                # #1059 SD3: counted when attempted, so a raising compute is
+                # still visible as work.
+                sc.note_project_work("closedWeekComputes")
                 week_buckets, week_total = _aggregate_projects_week(
                     conn, week_start=w, week_end=w_end,
                     resolver_cache=resolver_cache,
@@ -7264,6 +7281,8 @@ def _build_projects_envelope(
     weeks_back: int = 12,
     use_projects_env_cache: bool = False,
     content_revision_leg: "str | None" = None,
+    project_resolver_cache: "dict | None" = None,
+    use_envelope_memo: bool = True,
 ) -> dict:
     """Build the ``projects.{current_week, trend}`` envelope block.
 
@@ -7300,6 +7319,13 @@ def _build_projects_envelope(
     lookup; the memo key carries it, so an in-place ``weekly_percent``
     correction (which moves no ``MAX(id)``) rebuilds the envelope. ``None``
     reads it here, on ``conn``.
+
+    #1059: ``project_resolver_cache`` is the resolver memo of the full-window
+    walk, passed through to the cached assembly; ``None`` keeps a fresh plain
+    dict (the walk) or an observing memo (the assembly). An owner build that
+    retains this result passes an observing memo so the identity sweep sees
+    every spelling. ``use_envelope_memo=False`` neither reads nor writes
+    ``_PROJECTS_ENV_MEMO``, for request-thread callers.
     """
     c = _cctally()
 
@@ -7354,7 +7380,7 @@ def _build_projects_envelope(
         cw_key = getattr(current_week, "week_start_at", None)
     memo_key = (max_id, max_wus_id, entry_mutation_seq, cw_key, weeks_back,
                 content_revision_leg)
-    cached = _PROJECTS_ENV_MEMO.get("value")
+    cached = _PROJECTS_ENV_MEMO.get("value") if use_envelope_memo else None
     if cached is not None and _PROJECTS_ENV_MEMO.get("key") == memo_key:
         return cached
 
@@ -7420,13 +7446,17 @@ def _build_projects_envelope(
         buckets, total_cost_by_week, key_by_bucket = _assemble_projects_via_cache(
             conn, week_bounds=week_bounds, cw_start=cw_start, cw_end=cw_end,
             cur_max_id=max_id, cur_max_seq=entry_mutation_seq,
+            resolver_cache=project_resolver_cache,
         )
     else:
         # `_resolve_project_key` is the production resolver; we use git-root
         # mode (default for `cmd_project --group` absent) — matches the
         # CLI's default.
         _resolve_project_key = c._resolve_project_key
-        resolver_cache: dict = {}
+        resolver_cache: dict = (
+            {} if project_resolver_cache is None else project_resolver_cache)
+        c._load_sibling("_lib_snapshot_cache").note_project_work(
+            "fullWindowProjectWalks")
 
         buckets = {}
         total_cost_by_week = {}
@@ -7787,8 +7817,9 @@ def _build_projects_envelope(
         "current_week": cw_block,
         "trend":        trend_block,
     }
-    _PROJECTS_ENV_MEMO["key"] = memo_key
-    _PROJECTS_ENV_MEMO["value"] = result
+    if use_envelope_memo:
+        _PROJECTS_ENV_MEMO["key"] = memo_key
+        _PROJECTS_ENV_MEMO["value"] = result
     return result
 
 
@@ -7849,11 +7880,15 @@ def _project_detail_for_window(
     if projects_envelope is not None:
         env = projects_envelope
     else:
+        # #1059: this fallback runs on a request thread (the `/api/project`
+        # handler passes `None` after a failed envelope build), so it must
+        # neither read nor write the owner's process-wide envelope memo.
         env = _build_projects_envelope(
             conn,
             now_utc=now_utc,
             current_week=current_week,
             weeks_back=weeks_back,
+            use_envelope_memo=False,
         )
 
     # Resolve project_key → bucket_path via the envelope's identity map.
@@ -8724,6 +8759,30 @@ def _debug_memory_owner(stats, *, prefix: str = "") -> dict:
     }
 
 
+def _debug_project_work() -> dict:
+    """#1059 SD3: the project work counters, or ``{}`` when unreadable."""
+    cctally = sys.modules.get("cctally")
+    loader = getattr(cctally, "_load_sibling", None)
+    if not callable(loader):
+        return {}
+    try:
+        return dict(loader("_lib_snapshot_cache").project_work_stats())
+    except Exception:  # noqa: BLE001 -- diagnostics fail closed.
+        return {}
+
+
+def _debug_project_identity() -> dict:
+    """#1059: the project-identity sweep block, or ``{}`` when unreadable."""
+    cctally = sys.modules.get("cctally")
+    loader = getattr(cctally, "_load_sibling", None)
+    if not callable(loader):
+        return {}
+    try:
+        return dict(loader("_lib_snapshot_cache").project_identity_stats())
+    except Exception:  # noqa: BLE001 -- diagnostics fail closed.
+        return {}
+
+
 def _debug_retained_memory(hub, *, main_frontier_stats=None) -> dict:
     """Numeric retained-owner ceilings; never values, keys or source paths."""
     owners: dict[str, dict] = {}
@@ -9610,6 +9669,13 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
             # #901 §5.5: kernel-accounted process writes, the trailing
             # five-minute statistic and its budget verdict. Additive camelCase.
             "writeIo": _debug_write_io(),
+            # #1059 SD3: cumulative counts at the project work sites, so a
+            # warm-tick measurement can prove no closed week was rebuilt.
+            # Additive and opaque, like every field of this diagnostic.
+            "projectWork": _debug_project_work(),
+            # #1059: the identity registry and sweep diagnostics, reported
+            # separately from the accelerator memory budget.
+            "projectIdentity": _debug_project_identity(),
         }
         if body["phases"] is None:
             body["note"] = "tracing_disabled"

package/bin/_cctally_dashboard_sources.py

@@ -7641,6 +7641,9 @@ def _capture_codex_accounting(
                     active_roots,
                     _cache_database_identity(context.cache_conn),
                 ),
+                # #1059: one observing memo per load, so every spelling the
+                # qualified resolution visits is registered for the regroup
+                # sweep.
                 load_all=lambda: load_qualified_codex_entries(
                     accounting_start,
                     accounting_end,
@@ -7648,6 +7651,8 @@ def _capture_codex_accounting(
                     sync=False,
                     cache_conn=context.cache_conn,
                     inventory=inventory,
+                    project_resolver_cache=(
+                        _lib_snapshot_cache.observing_project_memo()),
                 ),
                 load_paths=lambda identities: load_qualified_codex_entries(
                     accounting_start,
@@ -7657,6 +7662,8 @@ def _capture_codex_accounting(
                     cache_conn=context.cache_conn,
                     source_identities=identities,
                     inventory=inventory,
+                    project_resolver_cache=(
+                        _lib_snapshot_cache.observing_project_memo()),
                 ),
                 path_of=lambda entry: (
                     str(entry.source_root_key), str(entry.source_path),

package/bin/_cctally_db.py

@@ -4908,6 +4908,269 @@ def _apply_codex_quota_latest_summary(
         conn.execute("RELEASE codex_quota_latest_apply")
 
 
+# ── #1033 §5.1: the exact reset-anchor evidence summary ─────────────────────
+#
+# `CodexResetAnchorResolver._components_for` seeded every anchor group by
+# reading the group's whole quota history (328,727 rows for the measured weekly
+# group) on every appended Codex hook, twice (walk and journal applier). The
+# components depend only on each distinct raw reset's minimum order key and the
+# row count, so this table holds exactly that per in-scope
+# (root, slot, limit key, raw reset) bucket: `row_count`, the lexicographic
+# minimum `(source_path, line_offset, id)` (never independently minimized
+# columns) and `stale`. A stale row's stored minimum is the deleted minimum, a
+# strict lower bound of every survivor; the seed never reads a stale group and
+# the drain's repair unit re-derives it.
+#
+# Membership is `source = 'codex' AND observed_slot IS NOT NULL`; the raw TEXT
+# spelling is the key and the seed folds spellings and skips unparseable raws.
+#
+# The triggers use built-in functions only, so a head-52 binary opening this
+# store keeps them firing, and they never upsert (an outer INSERT OR IGNORE
+# propagates its conflict policy into trigger bodies): an UPDATE, then an
+# INSERT ... WHERE NOT EXISTS. Insert and delete maintenance runs only while
+# the state is `ready`; every statement is a primary-key operation, and the
+# delete trigger never searches quota_window_snapshots for a replacement
+# minimum (#971). An insert whose (source_path, line_offset) is at or below a
+# stale minimum's is the exact minimum (that pair is unique within a bucket),
+# so a heal's same-line reinsert clears the staleness its delete caused. An
+# UPDATE of any key or order column flips the state to `bootstrap` and
+# advances the generation, which the drain's publication token reads (the
+# change ledger excludes `id`). A REPLACE against the snapshots table would
+# delete without firing the delete trigger; test_no_writer_replaces_quota_rows
+# refuses one.
+
+CODEX_RESET_ANCHOR_EVIDENCE_STATE_KEY = "codex_reset_anchor_evidence"
+CODEX_RESET_ANCHOR_EVIDENCE_GENERATION_KEY = (
+    "codex_reset_anchor_evidence_generation")
+CODEX_RESET_ANCHOR_EVIDENCE_READY = "ready"
+CODEX_RESET_ANCHOR_EVIDENCE_BOOTSTRAP = "bootstrap"
+CODEX_RESET_ANCHOR_EVIDENCE_TABLE = "codex_reset_anchor_evidence"
+
+#: The five objects whose joint presence (with a valid state) means the summary
+#: has been maintained since it was last published.
+CODEX_RESET_ANCHOR_EVIDENCE_OBJECTS = (
+    ("table", "codex_reset_anchor_evidence"),
+    ("index", "idx_codex_reset_anchor_evidence_stale"),
+    ("trigger", "trg_qws_anchor_evidence_ins"),
+    ("trigger", "trg_qws_anchor_evidence_del"),
+    ("trigger", "trg_qws_anchor_evidence_upd"),
+)
+
+#: Every key or order column; an UPDATE of any of them invalidates readiness.
+_CODEX_RESET_ANCHOR_EVIDENCE_UPDATE_OF = (
+    "source", "source_root_key", "observed_slot", "logical_limit_key",
+    "resets_at_utc", "source_path", "line_offset", "id",
+)
+
+
+def _codex_reset_anchor_evidence_ddl() -> "tuple[str, ...]":
+    """DDL for the summary, its stale index and its three triggers.
+
+    Triggers are dropped and re-created on every apply, like the latest
+    summary's, so a definition change never leaves an older body behind; the
+    table keeps IF NOT EXISTS and its rows survive.
+    """
+    state = CODEX_RESET_ANCHOR_EVIDENCE_STATE_KEY
+    generation = CODEX_RESET_ANCHOR_EVIDENCE_GENERATION_KEY
+    ready = (f"(SELECT value FROM cache_meta WHERE key = '{state}')"
+             f" = '{CODEX_RESET_ANCHOR_EVIDENCE_READY}'")
+
+    def bucket(image: str) -> str:
+        return (f"source_root_key = {image}.source_root_key"
+                f" AND observed_slot = {image}.observed_slot"
+                f" AND logical_limit_key = {image}.logical_limit_key"
+                f" AND resets_at_utc = {image}.resets_at_utc")
+
+    def in_scope(image: str) -> str:
+        return (f"{image}.source = 'codex'"
+                f" AND {image}.observed_slot IS NOT NULL")
+
+    takes = (
+        "((stale = 0 AND (NEW.source_path, NEW.line_offset, NEW.id)"
+        " < (min_source_path, min_line_offset, min_id))"
+        " OR (stale = 1 AND (NEW.source_path, NEW.line_offset)"
+        " <= (min_source_path, min_line_offset)))")
+    differs = " OR ".join(
+        f"OLD.{column} IS NOT NEW.{column}"
+        for column in _CODEX_RESET_ANCHOR_EVIDENCE_UPDATE_OF)
+    return (
+        "CREATE TABLE IF NOT EXISTS codex_reset_anchor_evidence (\n"
+        "            source_root_key   TEXT    NOT NULL,\n"
+        "            observed_slot     TEXT    NOT NULL,\n"
+        "            logical_limit_key TEXT    NOT NULL,\n"
+        "            resets_at_utc     TEXT    NOT NULL,\n"
+        "            row_count         INTEGER NOT NULL CHECK (row_count > 0),\n"
+        "            min_source_path   TEXT    NOT NULL,\n"
+        "            min_line_offset   INTEGER NOT NULL,\n"
+        "            min_id            INTEGER NOT NULL,\n"
+        "            stale             INTEGER NOT NULL DEFAULT 0"
+        " CHECK (stale IN (0, 1)),\n"
+        "            PRIMARY KEY (source_root_key, observed_slot,"
+        " logical_limit_key, resets_at_utc)\n"
+        "        ) WITHOUT ROWID",
+        "CREATE INDEX IF NOT EXISTS idx_codex_reset_anchor_evidence_stale"
+        " ON codex_reset_anchor_evidence"
+        " (source_root_key, observed_slot, logical_limit_key)"
+        " WHERE stale = 1",
+        "DROP TRIGGER IF EXISTS trg_qws_anchor_evidence_ins",
+        "CREATE TRIGGER trg_qws_anchor_evidence_ins\n"
+        "        AFTER INSERT ON quota_window_snapshots\n"
+        f"        WHEN {in_scope('NEW')} AND {ready}\n"
+        "        BEGIN\n"
+        "            UPDATE codex_reset_anchor_evidence"
+        " SET row_count = row_count + 1,"
+        f" min_source_path = CASE WHEN {takes} THEN NEW.source_path"
+        " ELSE min_source_path END,"
+        f" min_line_offset = CASE WHEN {takes} THEN NEW.line_offset"
+        " ELSE min_line_offset END,"
+        f" min_id = CASE WHEN {takes} THEN NEW.id ELSE min_id END,"
+        f" stale = CASE WHEN {takes} THEN 0 ELSE stale END"
+        f" WHERE {bucket('NEW')};\n"
+        "            INSERT INTO codex_reset_anchor_evidence"
+        " (source_root_key, observed_slot, logical_limit_key, resets_at_utc,"
+        " row_count, min_source_path, min_line_offset, min_id, stale)"
+        " SELECT NEW.source_root_key, NEW.observed_slot,"
+        " NEW.logical_limit_key, NEW.resets_at_utc, 1, NEW.source_path,"
+        " NEW.line_offset, NEW.id, 0"
+        " WHERE NOT EXISTS (SELECT 1 FROM codex_reset_anchor_evidence"
+        f" WHERE {bucket('NEW')});\n"
+        "        END",
+        "DROP TRIGGER IF EXISTS trg_qws_anchor_evidence_del",
+        "CREATE TRIGGER trg_qws_anchor_evidence_del\n"
+        "        AFTER DELETE ON quota_window_snapshots\n"
+        f"        WHEN {in_scope('OLD')} AND {ready}\n"
+        "        BEGIN\n"
+        "            UPDATE cache_meta"
+        f" SET value = '{CODEX_RESET_ANCHOR_EVIDENCE_BOOTSTRAP}'"
+        f" WHERE key = '{state}'"
+        " AND NOT EXISTS (SELECT 1 FROM codex_reset_anchor_evidence"
+        f" WHERE {bucket('OLD')});\n"
+        "            DELETE FROM codex_reset_anchor_evidence"
+        f" WHERE {bucket('OLD')} AND row_count = 1;\n"
+        "            UPDATE codex_reset_anchor_evidence"
+        " SET row_count = row_count - 1,"
+        " stale = CASE WHEN (min_source_path, min_line_offset, min_id)"
+        " = (OLD.source_path, OLD.line_offset, OLD.id) THEN 1 ELSE stale END"
+        f" WHERE {bucket('OLD')};\n"
+        "        END",
+        "DROP TRIGGER IF EXISTS trg_qws_anchor_evidence_upd",
+        "CREATE TRIGGER trg_qws_anchor_evidence_upd\n"
+        "        AFTER UPDATE OF "
+        f"{', '.join(_CODEX_RESET_ANCHOR_EVIDENCE_UPDATE_OF)}"
+        " ON quota_window_snapshots\n"
+        f"        WHEN (({in_scope('OLD')}) OR ({in_scope('NEW')}))"
+        f" AND ({differs})\n"
+        "        BEGIN\n"
+        "            UPDATE cache_meta"
+        " SET value = CAST(CAST(value AS INTEGER) + 1 AS TEXT)"
+        f" WHERE key = '{generation}';\n"
+        "            INSERT INTO cache_meta (key, value)"
+        f" SELECT '{generation}', '1' WHERE NOT EXISTS"
+        f" (SELECT 1 FROM cache_meta WHERE key = '{generation}');\n"
+        "            UPDATE cache_meta"
+        f" SET value = '{CODEX_RESET_ANCHOR_EVIDENCE_BOOTSTRAP}'"
+        f" WHERE key = '{state}'"
+        f" AND value = '{CODEX_RESET_ANCHOR_EVIDENCE_READY}';\n"
+        "        END",
+    )
+
+
+def _advance_codex_reset_anchor_evidence_generation(
+    conn: sqlite3.Connection,
+) -> None:
+    """Advance (or initialize) the invalidation generation in the caller's
+    transaction. A malformed stored value restarts from it parsed as 0."""
+    row = conn.execute(
+        "SELECT value FROM cache_meta WHERE key = ?",
+        (CODEX_RESET_ANCHOR_EVIDENCE_GENERATION_KEY,)).fetchone()
+    try:
+        current = int(row[0]) if row is not None else 0
+    except (TypeError, ValueError):
+        current = 0
+    conn.execute(
+        "INSERT INTO cache_meta(key, value) VALUES (?, ?) "
+        "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
+        (CODEX_RESET_ANCHOR_EVIDENCE_GENERATION_KEY, str(current + 1)))
+
+
+def _set_codex_reset_anchor_evidence_state(
+    conn: sqlite3.Connection, state: str,
+) -> None:
+    conn.execute(
+        "INSERT INTO cache_meta(key, value) VALUES (?, ?) "
+        "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
+        (CODEX_RESET_ANCHOR_EVIDENCE_STATE_KEY, state))
+
+
+def _apply_codex_reset_anchor_evidence(conn: sqlite3.Connection) -> None:
+    """Install the reset-anchor evidence summary on every delivery path.
+
+    Shared by ``_apply_cache_schema`` and migration 053 so fresh and upgraded
+    stores converge. Atomic like ``_apply_codex_retained_identity_inventory``:
+    the table, its stale index, the three triggers and the state commit
+    together, as a savepoint inside the caller's transaction or as an
+    IMMEDIATE transaction of their own.
+
+    The state is decided only when any of the five objects was missing before
+    this call, or the state key is missing or malformed: every summary row is
+    deleted, the generation advances and the state becomes ``ready`` when no
+    in-scope Codex quota row exists, else ``bootstrap`` for the drain's
+    off-hook bootstrap unit. A store carrying all five objects and a valid
+    state has been maintained since they were created, so its recorded state
+    stands (a markerless retry changes nothing). A history scan never runs
+    here: the population check is one LIMIT 1 probe. Guarded on the columns
+    the triggers read, which a legacy-shape cache whose schema apply returned
+    early can lack, and on ``cache_meta``.
+    """
+    columns = {
+        str(row[0]) for row in conn.execute(
+            "SELECT name FROM pragma_table_info('quota_window_snapshots')")
+    }
+    if not ({"id", *_CODEX_RESET_ANCHOR_EVIDENCE_UPDATE_OF} <= columns
+            and _table_exists(conn, "cache_meta")):
+        return
+    own_transaction = not conn.in_transaction
+    conn.execute(
+        "BEGIN IMMEDIATE" if own_transaction
+        else "SAVEPOINT codex_reset_anchor_evidence_apply")
+    try:
+        present = {
+            (str(row[0]), str(row[1])) for row in conn.execute(
+                "SELECT type, name FROM sqlite_master "
+                "WHERE type IN ('table', 'index', 'trigger')")
+        }
+        complete = all(
+            item in present for item in CODEX_RESET_ANCHOR_EVIDENCE_OBJECTS)
+        state_row = conn.execute(
+            "SELECT value FROM cache_meta WHERE key = ?",
+            (CODEX_RESET_ANCHOR_EVIDENCE_STATE_KEY,)).fetchone()
+        valid_state = state_row is not None and state_row[0] in (
+            CODEX_RESET_ANCHOR_EVIDENCE_READY,
+            CODEX_RESET_ANCHOR_EVIDENCE_BOOTSTRAP)
+        for statement in _codex_reset_anchor_evidence_ddl():
+            conn.execute(statement)
+        if not (complete and valid_state):
+            conn.execute("DELETE FROM codex_reset_anchor_evidence")
+            _advance_codex_reset_anchor_evidence_generation(conn)
+            populated = conn.execute(
+                "SELECT 1 FROM quota_window_snapshots WHERE source = 'codex' "
+                "AND observed_slot IS NOT NULL LIMIT 1").fetchone()
+            _set_codex_reset_anchor_evidence_state(
+                conn, CODEX_RESET_ANCHOR_EVIDENCE_BOOTSTRAP if populated
+                else CODEX_RESET_ANCHOR_EVIDENCE_READY)
+    except BaseException:
+        if own_transaction:
+            conn.rollback()
+        else:
+            conn.execute("ROLLBACK TO codex_reset_anchor_evidence_apply")
+            conn.execute("RELEASE codex_reset_anchor_evidence_apply")
+        raise
+    if own_transaction:
+        conn.commit()
+    else:
+        conn.execute("RELEASE codex_reset_anchor_evidence_apply")
+
+
 def _apply_codex_quota_load_order_index(conn: sqlite3.Connection) -> None:
     """The general loader's ORDER BY, served by an index (#901 §5.1, T1/T3).
 
@@ -5527,6 +5790,11 @@ CACHE_REDERIVABLE_OBJECTS: "tuple[SchemaDeliveryObject, ...]" = (
         "index", "idx_codex_files_root_thread",
         "_apply_codex_accounting_change_ledger",
         "052_codex_delete_trigger_plans"),
+    # #1033 spec §5.5: migration 053's handler calls the shared helper.
+    *(SchemaDeliveryObject(
+        kind, name, "_apply_codex_reset_anchor_evidence",
+        "053_codex_reset_anchor_evidence")
+      for kind, name in CODEX_RESET_ANCHOR_EVIDENCE_OBJECTS),
 )
 
 
@@ -6370,6 +6638,8 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
     # window-attribution read order (Amendment 1 item 1). BEFORE the
     # legacy-FTS early-return, so an old-shape cache.db gains them.
     _apply_codex_quota_latest_summary(conn)
+    # #1033 §5.5: the reset-anchor evidence summary and its readiness state.
+    _apply_codex_reset_anchor_evidence(conn)
     _apply_codex_quota_load_order_index(conn)
     _apply_codex_metadata_lookup_indexes(conn)
     _apply_pricing_model_indexes(conn)
@@ -6571,6 +6841,10 @@ def _apply_conversations_schema(conn: sqlite3.Connection) -> None:
         -- #927: the retained-identity inventory is cache.db prune state. Its
         -- triggers went with the four family tables dropped above.
         DROP TABLE IF EXISTS codex_retained_identities;
+        -- #1033: the reset-anchor evidence summary is a cache.db read model
+        -- over quota_window_snapshots, whose drop above took its triggers;
+        -- dropping the table takes its stale index.
+        DROP TABLE IF EXISTS codex_reset_anchor_evidence;
 
         CREATE TABLE IF NOT EXISTS conversation_source_files (
             path             TEXT PRIMARY KEY,
@@ -10848,6 +11122,36 @@ def _052_codex_delete_trigger_plans(conn: sqlite3.Connection) -> None:
     conn.commit()
 
 
+@cache_migration("053_codex_reset_anchor_evidence")
+def _053_codex_reset_anchor_evidence(conn: sqlite3.Connection) -> None:
+    """#1033 spec §5.5: deliver the reset-anchor evidence summary.
+
+    The schema apply that declares the table, its stale index and its three
+    triggers is version-gated, so only a registered migration reaches an
+    already-current store. The shared helper records ``ready`` when no
+    in-scope Codex quota row exists, else ``bootstrap``: the drain's
+    ``reset_anchor_evidence_bootstrap`` unit (or ``cache-sync`` inline)
+    aggregates an existing history off the hook, never here, so an ordinary
+    open pays no history scan. Until then every seed falls back to the full
+    read, which is today's behaviour.
+
+    Downgrade: a head-52 binary opening a head-53 store never reads the
+    summary, and the dispatcher's version-ahead recovery trims this marker.
+    The built-in-only triggers keep maintaining a ``ready`` summary under its
+    writes, including its row-by-row ``_clear_codex_derived_rows``, which
+    empties the summary exactly; a ``bootstrap`` summary stays inert. A
+    re-upgrade re-runs this handler, finds every object and a valid state, and
+    changes nothing.
+
+    Takes no provider flock: the helper's IMMEDIATE transaction (or savepoint)
+    makes the trigger creation and the state decision atomic against every
+    writer. Re-running is a no-op. NO self-stamp — the dispatcher
+    central-stamps on a clean return (#140).
+    """
+    _apply_codex_reset_anchor_evidence(conn)
+    conn.commit()
+
+
 # === Region 7d: Stats migration 008_recompute_weekly_cost_snapshots_dedup_fix ===
 
 @stats_migration("008_recompute_weekly_cost_snapshots_dedup_fix")

package/bin/_cctally_source_analytics.py

@@ -1160,9 +1160,16 @@ class _CodexProjectResolution:
 
     __slots__ = ("_group", "_resolver_cache", "_by_cwd", "_by_git_json")
 
-    def __init__(self, group: str = "git-root") -> None:
+    def __init__(
+        self, group: str = "git-root",
+        resolver_cache: "dict[object, object] | None" = None,
+    ) -> None:
         self._group = group
-        self._resolver_cache: dict[object, object] = {}
+        # #1059: the owner's dashboard loads pass an observing memo so every
+        # spelling this resolution visits is registered for the regroup
+        # sweep; every other caller keeps a private plain dict.
+        self._resolver_cache: dict[object, object] = (
+            {} if resolver_cache is None else resolver_cache)
         self._by_cwd: dict[str, object] = {}
         self._by_git_json: dict[str, str | None] = {}
 
@@ -1248,6 +1255,7 @@ def load_qualified_codex_entries(
     source_identities: Iterable[tuple[str, str]] | None = None,
     inventory: "CodexThreadMetadataInventory | None" = None,
     _on_sync: "Callable[[object], object] | None" = None,
+    project_resolver_cache: "dict[object, object] | None" = None,
 ) -> tuple[QualifiedCodexEntry, ...]:
     """Load exactly one bounded, root-qualified Codex accounting read.
 
@@ -1316,7 +1324,10 @@ def load_qualified_codex_entries(
             conn.row_factory = previous_row_factory
 
     return _qualify_codex_rows(
-        rows, inherited_metadata, speed=speed, group=group)
+        rows, inherited_metadata, speed=speed, group=group,
+        projects=_CodexProjectResolution(
+            group, resolver_cache=project_resolver_cache),
+    )
 
 
 def _qualify_codex_rows(