cctally 1.61.0 → 1.63.0

package/bin/_cctally_dashboard.py

@@ -317,16 +317,21 @@ from _lib_blocks import _group_entries_into_blocks
 from _cctally_config import save_config, _load_config_unlocked
 from _cctally_db import _render_migration_error_banner
 from _cctally_cache import (
-    get_entries, iter_entries, open_cache_db, sync_cache,
+    get_entries, iter_entries, iter_entries_with_id, open_cache_db, sync_cache,
     _prune_orphaned_cache_entries,
 )
 from _lib_snapshot_cache import (
     build_cached_group_a,
     bump_generation,
+    cached_bugk_segment,
+    reset_bugk_segment_state,
+    reset_cache_report_state,
     reset_group_a_state,
     reset_projects_env_state,
     reset_session_cache_state,
     reset_weekref_cost_state,
+    BugKSegment,
+    _bugk_key,
     _max_id as _snapshot_max_id,
     _reset_sig as _snapshot_reset_sig,
 )
@@ -420,17 +425,25 @@ def _dashboard_self_heal_orphans(*, skip_sync):
             # #269 M3.2 (spec §6): the shared per-weekref immutable-cost cache
             # (B1 trend/weekly-history + B3 forecast) rides the SAME prune-site
             # clear — a non-max deletion the reconcile's max-id regression check
-            # can't catch. (B2 cache-report cache was dropped at the M2.0 gate,
-            # so there is no reset_cache_report_state() to call here.)
+            # can't catch.
             reset_weekref_cost_state()
+            # #272: the per-day cache-report cache rides the same prune-site
+            # clear — a non-max deletion inside a closed day the reconcile's
+            # max-id / mutation-seq regression check can't catch.
+            reset_cache_report_state()
             # #269 M4.5 (spec §14 Win 2): the projects-envelope per-(project,
             # week) cache rides the same prune-site clear for the same reason.
             reset_projects_env_state()
+            # #271 M3 (spec §18): the Bug-K pre-credit segment cache rides the
+            # same prune-site clear — a non-max deletion inside a closed
+            # pre-credit window the reconcile's max-id regression check can't
+            # catch.
+            reset_bugk_segment_state()
             # #269 (final reviewer): the per-(project, week) cache clear above is
             # NOT sufficient on its own. `_build_projects_envelope` consults the
             # whole-envelope memo `_PROJECTS_ENV_MEMO` FIRST — and its memo_key is
-            # `(max_id, max_wus_id, cw_key, weeks_back)`, which carries NO
-            # generation counter. A prune that deletes only NON-max
+            # `(max_id, max_wus_id, entry_mutation_seq, cw_key, weeks_back)`, which
+            # carries NO generation counter. A prune that deletes only NON-max
             # `session_entries` rows leaves `max_id` unchanged, so the memo_key
             # still matches and the memo would stale-serve the pre-prune envelope
             # (still showing the deleted project + its cost) before the fresh
@@ -2071,6 +2084,77 @@ def _cache_report_load_kernel():
     return sys.modules["cctally"]._load_sibling("_lib_cache_report")
 
 
+def _cache_report_needed_closed_dates(since, now_utc, bucket_tz):
+    """The CLOSED display-tz dates a full-window cache-report build needs (#272 §6).
+
+    Every display-tz calendar date overlapping ``[since, now_utc]`` EXCEPT the
+    current open day (Codex-2: a ``since``-straddling window yields up to
+    ``window_days + 1`` display dates, and classification runs over the full
+    set BEFORE the ``days`` cap). Returned sorted ascending. The ``have_all``
+    gate requires every one of these to be cached before serving the warm
+    (today-only-fetch) path. A genuinely activity-free calendar day produces
+    no per-day fold row, so the cold/miss populate branch stores an
+    ``is_empty`` sentinel (``empty_cached_day``) for every needed closed date
+    the fold didn't emit — registering the quiet day as a cache HIT (the same
+    computed-empty registration ``projects_env_week_put`` does for an empty
+    week). That keeps ``have_all`` reachable, so a weekend/vacation gap day
+    does NOT permanently defeat the warm path; the sentinel is skipped in the
+    restitch, so the output stays byte-identical to from-scratch.
+    """
+    today_key = now_utc.astimezone(bucket_tz).strftime("%Y-%m-%d")
+    d = since.astimezone(bucket_tz).date()
+    end_date = now_utc.astimezone(bucket_tz).date()
+    out: list = []
+    while d <= end_date:
+        key = d.strftime("%Y-%m-%d")
+        if key != today_key:
+            out.append(key)
+        d += dt.timedelta(days=1)
+    return out
+
+
+def _day_start(date_iso, bucket_tz):
+    """The aware-UTC instant of ``date_iso``'s local midnight in ``bucket_tz`` (#272 §6).
+
+    Lower-bounds the warm-path current-day fetch so it returns exactly the
+    entries ``_aggregate_cache_by_day`` buckets to ``date_iso`` (which buckets
+    via ``entry.timestamp.astimezone(bucket_tz)``). DST-correct: attaching the
+    zone to the naive local-midnight then converting to UTC lets ``ZoneInfo``
+    pick the right offset for that wall time.
+    """
+    naive = dt.datetime.strptime(date_iso, "%Y-%m-%d")
+    return naive.replace(tzinfo=bucket_tz).astimezone(dt.timezone.utc)
+
+
+def _cache_report_empty(
+    *, today_iso, window_days, anomaly_threshold_pp, anomaly_window_days,
+):
+    """The empty (no in-window entries) ``CacheReportSnapshot`` — factored so the
+    warm and cold builder paths share one ``is_empty`` return (#272 §6)."""
+    empty_today = CacheReportTodaySpotlight(
+        date=today_iso,
+        cache_hit_percent=0.0,
+        baseline_median_percent=None,
+        delta_pp=None,
+        net_usd=0.0, saved_usd=0.0, wasted_usd=0.0,
+        anomaly_triggered=False,
+        anomaly_reasons=(),
+        baseline_daily_row_count=0,
+    )
+    return CacheReportSnapshot(
+        window_days=window_days,
+        anomaly_threshold_pp=anomaly_threshold_pp,
+        anomaly_window_days=anomaly_window_days,
+        today=empty_today,
+        days=(), by_project=(), by_model=(),
+        seven_day_net_usd=0.0,
+        seven_day_anomaly_count=0,
+        fourteen_day_counterfactual_usd=0.0,
+        fourteen_day_efficiency_ratio=0.0,
+        is_empty=True,
+    )
+
+
 def build_cache_report_snapshot(
     *,
     now_utc: dt.datetime,
@@ -2078,91 +2162,167 @@ def build_cache_report_snapshot(
     anomaly_window_days: int,
     display_tz: "ZoneInfo | None",
     skip_sync: bool = False,
+    use_cache_report_cache: bool = False,
 ) -> CacheReportSnapshot:
     """Build the ``cache_report`` envelope field from the session-entry cache.
 
     Pulls entries via ``get_claude_session_entries`` (uses the cache when
     warm, falls back to direct-JSONL parse on cache miss / lock
-    contention — same chain the CLI uses). Delegates aggregation +
-    anomaly classification to ``_lib_cache_report._build_cache_report``;
-    shapes the result into a frozen ``CacheReportSnapshot``.
+    contention — same chain the CLI uses). Aggregates per closed day via
+    ``_lib_cache_report.build_cached_days`` (served from the per-day cache
+    when ``use_cache_report_cache`` and reconciled), reconstructs fresh
+    rows (``reconstruct_cache_row``), runs the cross-row
+    ``classify_and_summarize`` + ``combine_day_project_partials`` restitch,
+    and shapes the result into a frozen ``CacheReportSnapshot``.
 
     ``window_days`` is hardcoded at 14 in v1 (spec §6.1 hardcodes
     ``anomaly_window_days`` too; ``anomaly_threshold_pp`` is the only
     user-configurable knob). F10 from spec §10 tracks making the window
     configurable, plus the UI-copy work it'd require.
+
+    **Per-day cache (#272 §6).** With ``use_cache_report_cache=True`` (set by
+    the dashboard sync thread AFTER ``reconcile_cache_report_cache`` succeeds),
+    the CLOSED days are served from the immutable per-day cache and only the
+    current (open) day is fetched + folded fresh — the warm-tick win. The
+    reconcile (in ``_tui_build_snapshot``) owns invalidation; this builder only
+    reads/populates the cache. With the flag OFF (default / safe fallback), the
+    full window is fetched every tick and the output is byte-identical to the
+    cached path (same restructured assembly, cache bypassed).
     """
     crk = _cache_report_load_kernel()
     cctally_ns = sys.modules["cctally"]
+    _sc = sys.modules["_lib_snapshot_cache"]
 
     window_days = CACHE_REPORT_WINDOW_DAYS  # v1: hardcoded per spec §6.1.
     since = now_utc - dt.timedelta(days=window_days)
+    pricing = cctally_ns.CLAUDE_MODEL_PRICING
 
-    entries = list(
-        get_claude_session_entries(since, now_utc, project=None, skip_sync=skip_sync)
-    )
-
+    # Cache mechanics key on the BUCKETING tz (``_resolve_bucket_tz`` — the same
+    # tz ``_aggregate_cache_by_day`` buckets by), so ``today_key`` / the closed-
+    # day keys line up with ``CacheRow.date``. The spotlight's ``today_iso``
+    # keeps its own UTC-fallback derivation unchanged (byte-identity); the two
+    # agree whenever ``display_tz`` is set — always, on the dashboard.
+    bucket_tz = crk._resolve_bucket_tz(display_tz)
+    today_key = now_utc.astimezone(bucket_tz).strftime("%Y-%m-%d")
     today_iso = now_utc.astimezone(
         display_tz if display_tz is not None else dt.timezone.utc
     ).strftime("%Y-%m-%d")
 
-    if not entries:
-        empty_today = CacheReportTodaySpotlight(
-            date=today_iso,
-            cache_hit_percent=0.0,
-            baseline_median_percent=None,
-            delta_pp=None,
-            net_usd=0.0, saved_usd=0.0, wasted_usd=0.0,
-            anomaly_triggered=False,
-            anomaly_reasons=(),
-            baseline_daily_row_count=0,
+    def _wrap_day_entries(raw):
+        # Day-mode kernel expects entries with a ``usage`` dict (matches
+        # ``UsageEntry``); ``get_claude_session_entries`` returns flat
+        # ``_JoinedClaudeEntry`` objects. SimpleNamespace keeps the wrapper
+        # pure-Python and avoids a new dataclass type just for the bridge.
+        from types import SimpleNamespace as _NS
+        return [
+            _NS(
+                timestamp=e.timestamp,
+                model=e.model,
+                cost_usd=e.cost_usd,
+                usage={
+                    "input_tokens": e.input_tokens,
+                    "output_tokens": e.output_tokens,
+                    "cache_creation_input_tokens": e.cache_creation_tokens,
+                    "cache_read_input_tokens": e.cache_read_tokens,
+                },
+            )
+            for e in raw
+        ]
+
+    # Which CLOSED display-tz dates the window needs (every date overlapping
+    # [since, now] except the current open day). If the cache holds them ALL,
+    # fetch only the current day (the warm win); else one full-window fetch
+    # (re)populates the closed days + recomputes today.
+    needed_closed = _cache_report_needed_closed_dates(since, now_utc, bucket_tz)
+    have_all = use_cache_report_cache and all(
+        _sc.cache_report_day_get(d) is not None for d in needed_closed
+    )
+
+    cached_days: dict = {}  # date_key -> CachedCacheReportDay
+    if have_all:
+        # Steady-state warm: recompute ONLY the open bucket; reuse cached closed.
+        raw_today = list(get_claude_session_entries(
+            _day_start(today_key, bucket_tz), now_utc,
+            project=None, skip_sync=skip_sync,
+        ))
+        built = crk.build_cached_days(
+            _wrap_day_entries(raw_today), raw_today,
+            display_tz=display_tz, pricing=pricing,
+            cost_calculator=_calculate_entry_cost,
+        )
+        for d in needed_closed:
+            cached_days[d] = _sc.cache_report_day_get(d)
+        cached_days.update(built)  # the fresh current day (today only)
+    else:
+        # Cold / partial-miss / post-eviction: pay one full-window fetch, then
+        # (re)compute + store every closed day. Runs on the rare stale tick.
+        raw = list(get_claude_session_entries(
+            since, now_utc, project=None, skip_sync=skip_sync,
+        ))
+        if not raw:
+            return _cache_report_empty(
+                today_iso=today_iso, window_days=window_days,
+                anomaly_threshold_pp=anomaly_threshold_pp,
+                anomaly_window_days=anomaly_window_days,
+            )
+        built = crk.build_cached_days(
+            _wrap_day_entries(raw), raw,
+            display_tz=display_tz, pricing=pricing,
+            cost_calculator=_calculate_entry_cost,
         )
-        return CacheReportSnapshot(
-            window_days=window_days,
+        cached_days = dict(built)
+        if use_cache_report_cache:
+            for d, unit in built.items():
+                if d != today_key:  # never store the OPEN day as a closed unit
+                    _sc.cache_report_day_store(d, unit)
+            # Empty/gap-day sentinel: a genuinely activity-free CLOSED day never
+            # appears in ``built`` (``build_cached_days`` only emits days with
+            # entries), so register an ``is_empty`` sentinel for every needed
+            # closed date the fold produced nothing for. Without this,
+            # ``have_all`` would see that quiet day as a perpetual miss and the
+            # builder would full-window-refetch on EVERY warm tick — permanently
+            # defeating the cache for any user with an off day. Mirrors
+            # ``projects_env_week_put`` registering a computed-empty week as a
+            # hit. ``needed_closed`` already excludes ``today_key``; the sentinel
+            # is skipped in the restitch below, so this is byte-identical.
+            for d in needed_closed:
+                if d not in built:
+                    _sc.cache_report_day_store(d, crk.empty_cached_day(d))
+            # Window-rolloff eviction (#275): the reconcile's seq-gated pass only
+            # evicts CHANGED days (>= the change watermark); days that roll off the
+            # trailing edge of the [since, now] window are never pruned there and
+            # would accrete one frozen unit/day on a long-uptime dashboard. Drop
+            # them here on this rare cold/rollover store tick (the warm path never
+            # reaches this branch). ``needed_closed`` is sorted ascending, so its
+            # first element is the window's oldest still-needed closed day; every
+            # needed day (real or ``is_empty`` sentinel) is >= it and survives.
+            if needed_closed:
+                _sc.cache_report_day_evict_before(needed_closed[0])
+
+    if not cached_days:
+        return _cache_report_empty(
+            today_iso=today_iso, window_days=window_days,
             anomaly_threshold_pp=anomaly_threshold_pp,
             anomaly_window_days=anomaly_window_days,
-            today=empty_today,
-            days=(), by_project=(), by_model=(),
-            seven_day_net_usd=0.0,
-            seven_day_anomaly_count=0,
-            fourteen_day_counterfactual_usd=0.0,
-            fourteen_day_efficiency_ratio=0.0,
-            is_empty=True,
         )
 
-    pricing = cctally_ns.CLAUDE_MODEL_PRICING
-
-    # Day-mode kernel expects entries with a ``usage`` dict (matches
-    # ``UsageEntry``). ``get_claude_session_entries`` returns flat
-    # ``_JoinedClaudeEntry`` objects, so wrap each into the right shape
-    # before passing to the kernel. SimpleNamespace keeps the wrapper
-    # pure-Python and avoids a new dataclass type just for the bridge.
-    from types import SimpleNamespace as _NS
-    day_entries = [
-        _NS(
-            timestamp=e.timestamp,
-            model=e.model,
-            cost_usd=e.cost_usd,
-            usage={
-                "input_tokens": e.input_tokens,
-                "output_tokens": e.output_tokens,
-                "cache_creation_input_tokens": e.cache_creation_tokens,
-                "cache_read_input_tokens": e.cache_read_tokens,
-            },
-        )
-        for e in entries
+    # Reconstruct fresh MUTABLE rows from the frozen cached days (F7 — cached
+    # units are never touched), then run the cross-row classify + summarize
+    # pass over the FULL assembled set every tick (the cached day aggregates
+    # carry no anomaly state).
+    rows = [
+        crk.reconstruct_cache_row(cached_days[d])
+        for d in sorted(cached_days)
+        if not cached_days[d].is_empty  # sentinel gap days emit no CacheRow
     ]
-
-    result = crk._build_cache_report(
-        day_entries,
+    result = crk.classify_and_summarize(
+        rows,
         now_utc=now_utc,
         window_days=window_days,
         anomaly_threshold_pp=anomaly_threshold_pp,
         anomaly_window_days=anomaly_window_days,
         display_tz=display_tz,
-        pricing=pricing,
         mode="day",
-        cost_calculator=_calculate_entry_cost,
     )
 
     # Pick out today's row (if any) and the baseline-daily-row count for
@@ -2299,17 +2459,22 @@ def build_cache_report_snapshot(
     # cache entry and its corresponding day row always agree on which
     # bucket they belong to.
     kept_dates = frozenset(r.date for r in days if r.date)
-    bucket_tz = display_tz if display_tz is not None else dt.timezone.utc
-    entries_in_window = [
-        e for e in entries
-        if e.timestamp.astimezone(bucket_tz).strftime("%Y-%m-%d") in kept_dates
-    ]
     rows_in_window = [r for r in result.rows if r.date in kept_dates]
-    by_project_rows = crk._aggregate_cache_breakdown(
-        entries_in_window,
-        key_fn=lambda e: (getattr(e, "project_path", None) or "(unknown)"),
-        pricing=pricing,
-        skip_synthetic=True,
+    # by_project via the #272 §4 two-level ``stable_sum`` fold
+    # (grouping-invariant). The per-(day, project) partials are carried on each
+    # ``CachedCacheReportDay`` (§5) — served from cache for closed days and
+    # freshly folded for today — so restitching them here memoizes the fold
+    # byte-identically. Their day keys use ``_resolve_bucket_tz(display_tz)``
+    # (matching ``CacheRow.date`` / ``kept_dates``), so combining over
+    # ``kept_dates`` is exactly the old full-window slice, modulo the one-time
+    # ULP fold move. Every ``kept_date`` is in ``cached_days`` (it came from a
+    # day row); the ``if d in cached_days`` guard is defensive.
+    by_project_rows = crk.combine_day_project_partials(
+        {
+            d: dict(cached_days[d].project_partials)
+            for d in kept_dates
+            if d in cached_days and not cached_days[d].is_empty
+        }
     )
     by_model_rows = crk._aggregate_cache_breakdown_from_rows(
         rows_in_window,
@@ -2629,6 +2794,33 @@ def _group_a_monthly_buckets(now_utc, *, n, range_start, display_tz):
             _start, nxt = _month_bounds(label)
             return nxt + dt.timedelta(days=2)
 
+        # #271: current-bucket accumulator inputs. `_membership` IS
+        # `_aggregate_monthly`'s own key (display-tz `%Y-%m`);
+        # `_all_fetch`/`_delta_fetch` reuse `_fetch`'s ±2-day-padded month
+        # window (clamped to now_utc) via the `(id, UsageEntry)` delta sibling.
+        def _membership(e):
+            local = (
+                e.timestamp.astimezone(display_tz) if display_tz is not None
+                # internal fallback: host-local intentional
+                else e.timestamp.astimezone()
+            )
+            return local.strftime("%Y-%m") == current_label
+
+        def _current_window(label):
+            start, nxt = _month_bounds(label)
+            lo = max(start - dt.timedelta(days=2), range_start)
+            hi = min(nxt + dt.timedelta(days=2), now_utc)
+            return lo, hi
+
+        def _all_fetch(label):
+            lo, hi = _current_window(label)
+            return [] if hi <= lo else iter_entries_with_id(cache_conn, lo, hi)
+
+        def _delta_fetch(label, after_seq, after_ts):
+            lo, hi = _current_window(label)
+            return [] if hi <= lo else iter_entries_with_id(
+                cache_conn, lo, hi, after_seq=after_seq, after_ts=after_ts)
+
         buckets = build_cached_group_a(
             "monthly",
             cache_conn=cache_conn,
@@ -2638,6 +2830,11 @@ def _group_a_monthly_buckets(now_utc, *, n, range_start, display_tz):
             fetch_bucket_entries=_fetch,
             aggregate_one=_agg_one,
             extra_signature=("monthly", tz_sig),
+            use_current_accumulator=True,
+            now_utc=now_utc,
+            current_all_fetch=_all_fetch,
+            current_delta_fetch=_delta_fetch,
+            membership_of=_membership,
         )
         return tuple(buckets)
     finally:
@@ -2787,6 +2984,52 @@ def _group_a_weekly_buckets(stats_conn, now_utc, *, weeks):
             except ValueError:
                 return None
 
+        # #271: current-bucket accumulator inputs. Membership REUSES
+        # _aggregate_weekly's exact bisect + first-match-wins assignment
+        # (bin/_lib_aggregators.py::_week_key_or_none) — the parsed-bounds list
+        # is built identically (same order, same parse) so an entry in an
+        # overlap region (reset-day drift) keys to the SAME week the full pass
+        # assigns it. _all_fetch/_delta_fetch reuse _fetch's
+        # [week.start, min(week.end, now_utc)] window via the (id, UsageEntry)
+        # delta sibling.
+        _parsed_bounds = [
+            (parse_iso_datetime(w.start_ts, "week.start_ts"),
+             parse_iso_datetime(w.end_ts, "week.end_ts"),
+             w.start_date.isoformat())
+            for w in weeks
+        ]
+        _bound_starts = [b[0] for b in _parsed_bounds]
+
+        def _week_key(e):
+            ts = e.timestamp
+            idx = bisect.bisect_right(_bound_starts, ts) - 1
+            if idx < 0:
+                return None
+            while idx > 0 and (
+                _parsed_bounds[idx - 1][0] <= ts < _parsed_bounds[idx - 1][1]
+            ):
+                idx -= 1
+            s_dt, e_dt, key = _parsed_bounds[idx]
+            return key if s_dt <= ts < e_dt else None
+
+        def _membership(e):
+            return _week_key(e) == current_label
+
+        def _current_window(label):
+            w = sw_by_label[label]
+            s = parse_iso_datetime(w.start_ts, "week.start_ts")
+            e = parse_iso_datetime(w.end_ts, "week.end_ts")
+            return s, min(e, now_utc)
+
+        def _all_fetch(label):
+            s, hi = _current_window(label)
+            return [] if hi <= s else iter_entries_with_id(cache_conn, s, hi)
+
+        def _delta_fetch(label, after_seq, after_ts):
+            s, hi = _current_window(label)
+            return [] if hi <= s else iter_entries_with_id(
+                cache_conn, s, hi, after_seq=after_seq, after_ts=after_ts)
+
         buckets = build_cached_group_a(
             "weekly",
             cache_conn=cache_conn,
@@ -2796,6 +3039,11 @@ def _group_a_weekly_buckets(stats_conn, now_utc, *, weeks):
             fetch_bucket_entries=_fetch,
             aggregate_one=_agg_one,
             extra_signature=extra_signature,
+            use_current_accumulator=True,
+            now_utc=now_utc,
+            current_all_fetch=_all_fetch,
+            current_delta_fetch=_delta_fetch,
+            membership_of=_membership,
         )
         return tuple(buckets)
     finally:
@@ -2806,7 +3054,8 @@ def _dashboard_build_weekly_periods(conn: "sqlite3.Connection",
                                     now_utc: "dt.datetime",
                                     *, n: int = 12,
                                     skip_sync: bool = False,
-                                    use_group_a_cache: bool = False) -> "list[WeeklyPeriodRow]":
+                                    use_group_a_cache: bool = False,
+                                    use_bugk_segment_cache: bool = False) -> "list[WeeklyPeriodRow]":
     """Latest n subscription weeks as WeeklyPeriodRow, newest-first.
 
     Thin builder-using prelude + Bug-K pre-credit synthesis on top of
@@ -3019,23 +3268,59 @@ def _dashboard_build_weekly_periods(conn: "sqlite3.Connection",
             # or the fallback's wide fetch above did) rather than filtering a
             # wide `entries` list, so Bug-K works identically on the cached
             # path (where no wide entry list exists) and the fallback path.
-            pre_input = pre_output = pre_cc = pre_cr = 0
-            pre_cost = 0.0
-            pre_models: dict[str, float] = {}
-            pre_entry_count = 0
-            for e in get_entries(original_start_dt, eff_dt, skip_sync=True):
-                if original_start_dt <= e.timestamp < eff_dt:
-                    usage = e.usage
-                    pre_input  += usage.get("input_tokens", 0)
-                    pre_output += usage.get("output_tokens", 0)
-                    pre_cc     += usage.get("cache_creation_input_tokens", 0)
-                    pre_cr     += usage.get("cache_read_input_tokens", 0)
-                    c = _calc(
-                        e.model, usage, mode="auto", cost_usd=e.cost_usd,
-                    )
-                    pre_cost += c
-                    pre_models[e.model] = pre_models.get(e.model, 0.0) + c
-                    pre_entry_count += 1
+            #
+            # #271 §18: the [original_start, effective) window is a CLOSED past
+            # interval (effective is a historical credit moment), so this folded
+            # aggregate is IMMUTABLE — cache it byte-identically (the same
+            # "re-aggregate immutable history every tick" pattern the #269
+            # weekref cost cache fixed). `_compute_pre_segment` is the exact
+            # from-scratch fetch+fold closure; on the sync thread
+            # (`use_bugk_segment_cache=True`) it routes through
+            # `cached_bugk_segment` (get-or-compute over the canonical window
+            # key), on EVERY other caller (CLI / share / tests / reconcile-
+            # failed) it computes directly — byte-unchanged. The `used_pct`
+            # snapshot query + WeeklyPeriodRow build BELOW always rerun fresh
+            # from the segment (do NOT cache the row — Codex-BK-5).
+            def _compute_pre_segment(_orig=original_start_dt, _eff=eff_dt):
+                pi = po = pcc = pcr = 0
+                pcost = 0.0
+                pmodels: dict[str, float] = {}
+                pcount = 0
+                for e in get_entries(_orig, _eff, skip_sync=True):
+                    if _orig <= e.timestamp < _eff:
+                        usage = e.usage
+                        pi  += usage.get("input_tokens", 0)
+                        po  += usage.get("output_tokens", 0)
+                        pcc += usage.get("cache_creation_input_tokens", 0)
+                        pcr += usage.get("cache_read_input_tokens", 0)
+                        c = _calc(
+                            e.model, usage, mode="auto", cost_usd=e.cost_usd,
+                        )
+                        pcost += c
+                        pmodels[e.model] = pmodels.get(e.model, 0.0) + c
+                        pcount += 1
+                # Codex-BK-4: freeze `models` as a tuple of (model, cost) in
+                # first-seen (dict-insertion) order so the row's stable cost-desc
+                # sort tie-order can't be mutated after caching.
+                return BugKSegment(
+                    input=pi, output=po, cache_create=pcc, cache_read=pcr,
+                    cost=pcost, models=tuple(pmodels.items()), entry_count=pcount,
+                )
+
+            if use_bugk_segment_cache:
+                seg = cached_bugk_segment(
+                    key=_bugk_key(original_start_dt, eff_dt),
+                    compute=_compute_pre_segment,
+                )
+            else:
+                seg = _compute_pre_segment()
+            pre_input = seg.input
+            pre_output = seg.output
+            pre_cc = seg.cache_create
+            pre_cr = seg.cache_read
+            pre_cost = seg.cost
+            pre_models = seg.models  # ((model, cost), ...) in first-seen order
+            pre_entry_count = seg.entry_count
             if pre_entry_count == 0 and pre_cost <= 0:
                 # No measurable pre-credit activity — skip insertion.
                 continue
@@ -3058,9 +3343,12 @@ def _dashboard_build_weekly_periods(conn: "sqlite3.Connection",
             )
 
             pre_total = pre_input + pre_output + pre_cc + pre_cr
+            # `pre_models` is a first-seen-order tuple of (model, cost); the
+            # stable cost-desc sort preserves that tie-order byte-for-byte,
+            # identical to the pre-#271 `sorted(dict.items(), ...)`.
             pre_model_breakdowns = [
                 {"modelName": m, "cost": c}
-                for m, c in sorted(pre_models.items(), key=lambda kv: -kv[1])
+                for m, c in sorted(pre_models, key=lambda kv: -kv[1])
             ]
             pre_label = original_start_dt.strftime("%m-%d")
             pre_row = WeeklyPeriodRow(
@@ -3362,6 +3650,36 @@ def _group_a_daily_buckets(now_utc, *, n, display_tz):
                 + dt.timedelta(days=2)
             )
 
+        # #271: current-bucket accumulator inputs. `_membership` IS
+        # `_aggregate_daily`'s own key (display-tz `%Y-%m-%d`), so the id-bounded
+        # fetch keeps exactly the entries the full pass assigns to the current
+        # day, byte-identically. `_all_fetch`/`_delta_fetch` reuse `_fetch`'s
+        # ±1-day-padded window (clamped to now_utc) via the `(id, UsageEntry)`
+        # delta sibling.
+        def _membership(e):
+            local = (
+                e.timestamp.astimezone(display_tz) if display_tz is not None
+                # internal fallback: host-local intentional
+                else e.timestamp.astimezone()
+            )
+            return local.strftime("%Y-%m-%d") == current_label
+
+        def _current_window(label):
+            d = dt.date.fromisoformat(label)
+            base = dt.datetime(d.year, d.month, d.day, tzinfo=dt.timezone.utc)
+            lo = max(base - dt.timedelta(days=1), range_start)
+            hi = min(base + dt.timedelta(days=2), now_utc)
+            return lo, hi
+
+        def _all_fetch(label):
+            lo, hi = _current_window(label)
+            return [] if hi <= lo else iter_entries_with_id(cache_conn, lo, hi)
+
+        def _delta_fetch(label, after_seq, after_ts):
+            lo, hi = _current_window(label)
+            return [] if hi <= lo else iter_entries_with_id(
+                cache_conn, lo, hi, after_seq=after_seq, after_ts=after_ts)
+
         buckets = build_cached_group_a(
             "daily",
             cache_conn=cache_conn,
@@ -3371,6 +3689,11 @@ def _group_a_daily_buckets(now_utc, *, n, display_tz):
             fetch_bucket_entries=_fetch,
             aggregate_one=_agg_one,
             extra_signature=("daily", tz_sig),
+            use_current_accumulator=True,
+            now_utc=now_utc,
+            current_all_fetch=_all_fetch,
+            current_delta_fetch=_delta_fetch,
+            membership_of=_membership,
         )
         return tuple(buckets)
     finally:
@@ -3545,13 +3868,41 @@ def _projects_week_label(week_start: "dt.datetime") -> str:
 def _projects_iter_session_entries(conn: "sqlite3.Connection",
                                    *,
                                    since: "dt.datetime",
-                                   until: "dt.datetime"):
+                                   until: "dt.datetime",
+                                   after_seq: "int | None" = None):
     """Read ``session_entries`` joined with ``session_files`` over
     [since, until]. Yields rows directly off the passed conn — no
     cache.db monkeypatch, no production ``get_claude_session_entries``
     pipeline. The fixture DBs co-locate both schemas in one file; the
     production wiring opens both DBs and ATTACHes cache.db as a schema
     on the stats conn (see ``_run_dashboard_sync_tick``).
+
+    ``after_seq`` (#270 §8, re-key of Codex-P2b — #271 §20): when set, the
+    current-week accumulator's warm delta seeks by the **mutation_seq range**
+    (``WHERE e.mutation_seq > ?``) with the ``[since, until]`` timestamp bounds
+    applied as a residual filter. Two hints keep the planner on the
+    ``idx_entries_mutation_seq`` seek (``SEARCH e USING INDEX
+    idx_entries_mutation_seq (mutation_seq>?)``) instead of a full ``SCAN`` /
+    ``idx_entries_timestamp`` window scan (which would re-read the whole ~12K-entry
+    current week and let the ~63ms floor creep back): (1) the unary-plus no-op
+    ``+e.timestamp_utc`` deprioritizes ``idx_entries_timestamp`` (a TRUE no-op —
+    it preserves the TEXT value AND the string comparison, unlike ``+ 0``); and
+    (2) ``ORDER BY e.mutation_seq`` matches the index's leading column so the
+    planner satisfies the order from the seek itself. ``INDEXED BY`` is NOT usable
+    here — production runs this against a TEMP VIEW (``session_entries`` over the
+    ATTACHed ``cache_db.session_entries``), and a view has no indexes; the hint
+    pair drives the same seek on both the view and a base-table fixture. Unlike
+    the old ``e.id > ?`` leg (a free INTEGER PRIMARY KEY rowid range), a bare
+    ``e.mutation_seq > ?`` lets the planner fall back to a scan on a small table,
+    so the hints are load-bearing. Re-keying from ``e.id`` to ``e.mutation_seq``
+    catches an id-stable in-place finalization (it advances the seq while
+    ``MAX(id)`` stays flat, so the pre-#270 ``e.id > ?`` leg missed it); on a
+    pure-insert tick ``{mutation_seq > ?}`` == ``{id > ?}`` (seq monotone with
+    id), so the delta row SET is byte-identical. The caller (``_fetch_delta_rows``)
+    re-sorts the small result by ``(timestamp_utc, id)`` to reproduce the full
+    pass's fold order, so the ``mutation_seq``-ASC SQL order is irrelevant
+    downstream. An ``EXPLAIN QUERY PLAN`` regression asserts the mutation_seq
+    index seek (``tests/test_projects_envelope.py``).
     """
     since_iso = since.astimezone(dt.timezone.utc).strftime(
         "%Y-%m-%dT%H:%M:%SZ"
@@ -3559,17 +3910,30 @@ def _projects_iter_session_entries(conn: "sqlite3.Connection",
     until_iso = until.astimezone(dt.timezone.utc).strftime(
         "%Y-%m-%dT%H:%M:%SZ"
     )
-    cur = conn.execute(
-        "SELECT e.id, e.timestamp_utc, e.model, e.input_tokens, "
-        "       e.output_tokens, e.cache_create_tokens, e.cache_read_tokens, "
-        "       e.cost_usd_raw, e.source_path, "
-        "       sf.session_id, sf.project_path "
-        "FROM session_entries e "
-        "LEFT JOIN session_files sf ON sf.path = e.source_path "
-        "WHERE e.timestamp_utc >= ? AND e.timestamp_utc <= ? "
-        "ORDER BY e.timestamp_utc ASC, e.id ASC",
-        (since_iso, until_iso),
-    )
+    if after_seq is not None:
+        cur = conn.execute(
+            "SELECT e.id, e.timestamp_utc, e.model, e.input_tokens, "
+            "       e.output_tokens, e.cache_create_tokens, e.cache_read_tokens, "
+            "       e.cost_usd_raw, e.source_path, "
+            "       sf.session_id, sf.project_path "
+            "FROM session_entries e "
+            "LEFT JOIN session_files sf ON sf.path = e.source_path "
+            "WHERE e.mutation_seq > ? AND +e.timestamp_utc >= ? AND +e.timestamp_utc <= ? "
+            "ORDER BY e.mutation_seq ASC",
+            (after_seq, since_iso, until_iso),
+        )
+    else:
+        cur = conn.execute(
+            "SELECT e.id, e.timestamp_utc, e.model, e.input_tokens, "
+            "       e.output_tokens, e.cache_create_tokens, e.cache_read_tokens, "
+            "       e.cost_usd_raw, e.source_path, "
+            "       sf.session_id, sf.project_path "
+            "FROM session_entries e "
+            "LEFT JOIN session_files sf ON sf.path = e.source_path "
+            "WHERE e.timestamp_utc >= ? AND e.timestamp_utc <= ? "
+            "ORDER BY e.timestamp_utc ASC, e.id ASC",
+            (since_iso, until_iso),
+        )
     for row in cur:
         yield row
 
@@ -3600,77 +3964,121 @@ class _ProjWeekBucket(NamedTuple):
     first_key: "Any"
 
 
-def _aggregate_projects_week(
+def _fold_projects_entry(
+    mut: dict,
+    row: tuple,
+    *,
+    resolver_cache: dict,
+    week_start: "dt.datetime",
+) -> "float | None":
+    """Fold ONE ``_projects_iter_session_entries`` row onto ``mut`` (the shared
+    per-row body, #271 §20 Codex-P1a).
+
+    Used by BOTH the full-window cold fold (``_aggregate_projects_week_raw``)
+    and the current-week accumulator's warm incremental append, so their
+    per-bucket cost sums, session sets, and first/last-seen captures are
+    byte-identical BY CONSTRUCTION. Returns the entry cost, or ``None`` when the
+    row is filtered out (``<synthetic>`` model, or its Monday-anchored week ≠
+    ``week_start``) — the caller then skips ``week_total`` / ``tail`` advance.
+
+    ``mut[bp]`` is the running mutable dict ``{"cost_usd": float,
+    "sessions": set, "first_seen": dt, "last_seen": dt, "first_order": ts_iso,
+    "first_id": int, "first_key": ProjectKey}``. The first row seen for a
+    ``bucket_path`` captures ``first_order`` / ``first_id`` / ``first_key`` —
+    order-safe for the warm append because every delta row sorts strictly after
+    ``tail`` (#271 §20), so a delta row is never the first-seen of a bucket that
+    already exists in ``mut``.
+    """
+    c = _cctally()
+    (entry_id, ts_iso, model, input_tok, output_tok,
+     cache_create, cache_read, cost_raw, source_path,
+     session_id, project_path) = row
+    if model == "<synthetic>":
+        return None
+    ts = parse_iso_datetime(ts_iso, "session_entries.timestamp_utc")
+    if _projects_week_start_monday_utc(ts) != week_start:
+        return None
+    entry_cost = _calculate_entry_cost(
+        model,
+        {
+            "input_tokens": input_tok or 0,
+            "output_tokens": output_tok or 0,
+            "cache_creation_input_tokens": cache_create or 0,
+            "cache_read_input_tokens": cache_read or 0,
+        },
+        mode="auto",
+        cost_usd=cost_raw,
+    )
+    pkey = c._resolve_project_key(project_path, "git-root", resolver_cache)
+    bp = pkey.bucket_path
+    a = mut.get(bp)
+    if a is None:
+        a = {
+            "cost_usd": 0.0,
+            "sessions": set(),
+            "first_seen": ts,
+            "last_seen": ts,
+            "first_order": ts_iso,
+            "first_id": entry_id,
+            "first_key": pkey,
+        }
+        mut[bp] = a
+    a["cost_usd"] += entry_cost
+    if session_id:
+        a["sessions"].add(session_id)
+    elif source_path:
+        a["sessions"].add(source_path)
+    if ts < a["first_seen"]:
+        a["first_seen"] = ts
+    if ts > a["last_seen"]:
+        a["last_seen"] = ts
+    return entry_cost
+
+
+def _aggregate_projects_week_raw(
     conn: "sqlite3.Connection",
     *,
     week_start: "dt.datetime",
     week_end: "dt.datetime",
     resolver_cache: dict,
-) -> "tuple[dict[str, _ProjWeekBucket], float]":
-    """Aggregate one Monday-anchored subscription week's entry slice.
-
-    Returns ``({bucket_path: _ProjWeekBucket}, week_total_cost)``. Byte-identical
-    to the contribution the full-window walk in ``_build_projects_envelope``
-    makes for this week: the per-week query returns entries in the same
-    ``timestamp_utc ASC, id ASC`` order, filtered to those whose
-    Monday-anchored week equals ``week_start``, so the per-bucket cost sum, the
-    entry-order ``week_total`` sum, the session set, and the first/last-seen +
-    SQL-first-entry captures all reproduce the full pass. ``week_end`` is the
-    inclusive query bound (``<= ?``); the exact next-Monday boundary entry is
-    fetched but filtered out (it belongs to the next week) — the next week's
-    slice keeps it, so no entry is lost or double-counted.
+) -> "tuple[dict, float, tuple | None]":
+    """Full-window fold for one Monday-anchored subscription week, returning the
+    RAW mutable ``mut`` (sessions kept as SETS, so the current-week accumulator
+    can dedup across ticks), the entry-order ``week_total`` float, and the
+    ``tail`` ``(ts_iso, id)`` of the last folded CURRENT-WEEK entry (``None``
+    when no row folded).
+
+    Shared by the finalizing ``_aggregate_projects_week`` wrapper (closed-week
+    cache path) and the current-week accumulator's cold seed (#271 §20
+    Codex-P1a — the finalized public shape discards the sessions SET into a
+    count, so cold seeding needs the raw ``mut``). Byte-identical to the
+    original single-loop aggregate: same ``timestamp_utc ASC, id ASC`` order,
+    same per-row ``_fold_projects_entry`` arithmetic, same entry-order
+    ``week_total`` left-fold.
     """
-    c = _cctally()
-    _resolve_project_key = c._resolve_project_key
-    week_total = 0.0
     mut: "dict[str, dict]" = {}
+    week_total = 0.0
+    tail: "tuple | None" = None
     for row in _projects_iter_session_entries(
         conn, since=week_start, until=week_end,
     ):
-        (entry_id, ts_iso, model, input_tok, output_tok,
-         cache_create, cache_read, cost_raw, source_path,
-         session_id, project_path) = row
-        if model == "<synthetic>":
-            continue
-        ts = parse_iso_datetime(ts_iso, "session_entries.timestamp_utc")
-        if _projects_week_start_monday_utc(ts) != week_start:
-            continue
-        entry_cost = _calculate_entry_cost(
-            model,
-            {
-                "input_tokens": input_tok or 0,
-                "output_tokens": output_tok or 0,
-                "cache_creation_input_tokens": cache_create or 0,
-                "cache_read_input_tokens": cache_read or 0,
-            },
-            mode="auto",
-            cost_usd=cost_raw,
+        entry_cost = _fold_projects_entry(
+            mut, row, resolver_cache=resolver_cache, week_start=week_start,
         )
-        pkey = _resolve_project_key(project_path, "git-root", resolver_cache)
-        bp = pkey.bucket_path
-        a = mut.get(bp)
-        if a is None:
-            a = {
-                "cost_usd": 0.0,
-                "sessions": set(),
-                "first_seen": ts,
-                "last_seen": ts,
-                "first_order": ts_iso,
-                "first_id": entry_id,
-                "first_key": pkey,
-            }
-            mut[bp] = a
-        a["cost_usd"] += entry_cost
-        if session_id:
-            a["sessions"].add(session_id)
-        elif source_path:
-            a["sessions"].add(source_path)
-        if ts < a["first_seen"]:
-            a["first_seen"] = ts
-        if ts > a["last_seen"]:
-            a["last_seen"] = ts
+        if entry_cost is None:
+            continue
         week_total += entry_cost
-    out = {
+        tail = (row[1], row[0])  # (ts_iso, id)
+    return mut, week_total, tail
+
+
+def _finalize_projects_mut(mut: dict) -> "dict[str, _ProjWeekBucket]":
+    """Finalize a raw ``mut`` (sessions SETS) into ``{bucket_path:
+    _ProjWeekBucket}`` — ``sessions_count = len(sessions)``, the rest copied
+    through. The public shape both the closed-week cache and the current-week
+    accumulator return (#271 §20).
+    """
+    return {
         bp: _ProjWeekBucket(
             cost_usd=a["cost_usd"],
             sessions_count=len(a["sessions"]),
@@ -3682,7 +4090,37 @@ def _aggregate_projects_week(
         )
         for bp, a in mut.items()
     }
-    return out, week_total
+
+
+def _aggregate_projects_week(
+    conn: "sqlite3.Connection",
+    *,
+    week_start: "dt.datetime",
+    week_end: "dt.datetime",
+    resolver_cache: dict,
+) -> "tuple[dict[str, _ProjWeekBucket], float]":
+    """Aggregate one Monday-anchored subscription week's entry slice.
+
+    Returns ``({bucket_path: _ProjWeekBucket}, week_total_cost)``. Byte-identical
+    to the contribution the full-window walk in ``_build_projects_envelope``
+    makes for this week: the per-week query returns entries in the same
+    ``timestamp_utc ASC, id ASC`` order, filtered to those whose
+    Monday-anchored week equals ``week_start``, so the per-bucket cost sum, the
+    entry-order ``week_total`` sum, the session set, and the first/last-seen +
+    SQL-first-entry captures all reproduce the full pass. ``week_end`` is the
+    inclusive query bound (``<= ?``); the exact next-Monday boundary entry is
+    fetched but filtered out (it belongs to the next week) — the next week's
+    slice keeps it, so no entry is lost or double-counted.
+
+    Thin wrapper over ``_aggregate_projects_week_raw`` + ``_finalize_projects_mut``
+    (#271 §20 Codex-P1a); the public shape is unchanged for the closed-week
+    cache path.
+    """
+    mut, week_total, _tail = _aggregate_projects_week_raw(
+        conn, week_start=week_start, week_end=week_end,
+        resolver_cache=resolver_cache,
+    )
+    return _finalize_projects_mut(mut), week_total
 
 
 def _assemble_projects_via_cache(
@@ -3691,6 +4129,8 @@ def _assemble_projects_via_cache(
     weeks_full: "list[dt.datetime]",
     cw_start: "dt.datetime",
     cw_end: "dt.datetime",
+    cur_max_id: int,
+    cur_max_seq: int,
 ) -> "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
@@ -3698,6 +4138,16 @@ def _assemble_projects_via_cache(
     Codex-M4 P2). Returns ``(buckets, total_cost_by_week, key_by_bucket)`` in the
     exact shape the from-scratch walk produces, so the downstream disambiguation
     / attribution / trend assembly runs unchanged and byte-identically.
+
+    #271 M4 (spec §20): the CURRENT week is no longer re-folded from scratch each
+    warm tick — it goes through the single-slot ``accumulate_projects_current_week``
+    accumulator, which folds only the changed-row delta (or finalizes the cached
+    running ``mut`` unchanged on an empty-delta tick), byte-identically.
+    ``cur_max_id`` is the tick's ``MAX(session_entries.id)`` (the regression
+    backstop + pre-existing-row cold-refold trigger); ``cur_max_seq`` is the
+    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).
     """
     c = _cctally()
     sc = c._load_sibling("_lib_snapshot_cache")
@@ -3730,10 +4180,45 @@ def _assemble_projects_via_cache(
                 best_order[bp] = cand
                 key_by_bucket[bp] = wb.first_key
 
+    def _fetch_all_raw():
+        return _aggregate_projects_week_raw(
+            conn, week_start=cw_start, week_end=cw_end,
+            resolver_cache=resolver_cache,
+        )
+
+    def _fetch_delta_rows(after_seq):
+        # Index-seek the changed-row delta (mutation_seq > after_seq, #270 §8)
+        # over the current-week window, then PRE-FILTER to genuine current-week
+        # non-synthetic rows (mirrors _fold_projects_entry's membership filter) so
+        # the accumulator's fold-order gate compares a REAL current-week entry as
+        # rows[0]. Sort by (ts_iso, id) to reproduce the full pass's fold order
+        # exactly (SQLite BINARY collation on the Z-normalized ISO string ==
+        # Python str compare).
+        out = []
+        for r in _projects_iter_session_entries(
+            conn, since=cw_start, until=cw_end, after_seq=after_seq,
+        ):
+            if r[2] == "<synthetic>":  # r[2] = model
+                continue
+            ts = parse_iso_datetime(r[1], "session_entries.timestamp_utc")
+            if _projects_week_start_monday_utc(ts) != cw_start:
+                continue
+            out.append(r)
+        out.sort(key=lambda r: (r[1], r[0]))  # (ts_iso, id)
+        return out
+
     for w in weeks_full:
         if w == cw_start:
-            week_buckets, week_total = _aggregate_projects_week(
-                conn, week_start=w, week_end=cw_end, resolver_cache=resolver_cache,
+            week_buckets, week_total = sc.accumulate_projects_current_week(
+                week_key=sc.projects_env_week_key(cw_start),
+                cur_max_id=cur_max_id,
+                cur_max_seq=cur_max_seq,
+                fetch_all_raw=_fetch_all_raw,
+                fetch_delta_rows=_fetch_delta_rows,
+                finalize=_finalize_projects_mut,
+                fold=lambda mut, row: _fold_projects_entry(
+                    mut, row, resolver_cache=resolver_cache, week_start=cw_start,
+                ),
             )
         else:
             week_iso = sc.projects_env_week_key(w)
@@ -3777,7 +4262,9 @@ def _build_projects_envelope(
 
     Determinism: same conn + same ``now_utc`` ⇒ byte-identical JSON
     (R-PROJ5 invariant). Per-tick memoized on
-    ``(max(session_entries.id), cw_week_start, weeks_back)``.
+    ``(max(session_entries.id), max_wus_id, max(mutation_seq), cw_week_start,
+    weeks_back)`` — the ``mutation_seq`` leg (#270 §7d) busts the memo on an
+    id-stable in-place finalization.
     """
     c = _cctally()
 
@@ -3797,10 +4284,30 @@ def _build_projects_envelope(
         max_wus_id = cur.fetchone()[0]
     except sqlite3.OperationalError:
         max_wus_id = 0
+    # #270 (§7d, Codex-2b): this OUTER whole-envelope memo returns BEFORE the
+    # inner per-(project, week) reconcile cache, so an id-stable in-place
+    # finalization — which leaves MAX(id)/MAX(wus id) flat — would serve the
+    # stale envelope regardless of the inner seq fix. Fold the mutation signal
+    # into the memo key so it busts on any changed row. `MAX(mutation_seq)` is
+    # read off the SAME `session_entries` surface as `max_id` (an id-stable
+    # UPSERT advances it), index-backed by `idx_entries_mutation_seq`, and
+    # degrades to 0 where the column is absent (old fixtures) — byte-identical.
+    # Deliberately `MAX(mutation_seq)`, NOT the `cache_meta` counter the reconciles
+    # read via `_entry_mutation_seq` (this conn is a project-detail view without a
+    # `cache_meta` surface). The two are consistent — the counter is always
+    # >= MAX(mutation_seq), and no row exists strictly between them at read time —
+    # so do not "unify" them here (the divergence is intentional; see #270 §M3-1).
+    try:
+        cur = conn.execute(
+            "SELECT COALESCE(MAX(mutation_seq), 0) FROM session_entries"
+        )
+        entry_mutation_seq = cur.fetchone()[0]
+    except sqlite3.OperationalError:
+        entry_mutation_seq = 0
     cw_key: "dt.datetime | None" = None
     if current_week is not None:
         cw_key = getattr(current_week, "week_start_at", None)
-    memo_key = (max_id, max_wus_id, cw_key, weeks_back)
+    memo_key = (max_id, max_wus_id, entry_mutation_seq, cw_key, weeks_back)
     cached = _PROJECTS_ENV_MEMO.get("value")
     if cached is not None and _PROJECTS_ENV_MEMO.get("key") == memo_key:
         return cached
@@ -3848,6 +4355,7 @@ def _build_projects_envelope(
     if use_projects_env_cache:
         buckets, total_cost_by_week, key_by_bucket = _assemble_projects_via_cache(
             conn, weeks_full=weeks_full, cw_start=cw_start, cw_end=cw_end,
+            cur_max_id=max_id, cur_max_seq=entry_mutation_seq,
         )
     else:
         # `_resolve_project_key` is the production resolver; we use git-root