cctally 1.7.2 → 1.7.4

package/bin/_cctally_dashboard.py

@@ -251,121 +251,55 @@ def _cctally():
     return sys.modules["cctally"]
 
 
+# === Honest imports from extracted homes ===================================
+# Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3: kernel symbols
+# import from _cctally_core; already-decentralized buckets (X = _lib_*,
+# Y = _cctally_*) import from their natural home. These bypass the
+# legacy shim pattern entirely.
+from _cctally_core import (
+    eprint,
+    now_utc_iso,
+    parse_iso_datetime,
+    _now_utc,
+    _command_as_of,
+    open_db,
+    get_latest_usage_for_week,
+    make_week_ref,
+    _get_alerts_config,
+    _AlertsConfigError,
+)
+from _lib_display_tz import (
+    format_display_dt,
+    resolve_display_tz,
+    normalize_display_tz_value,
+    _compute_display_block,
+)
+from _lib_aggregators import _aggregate_daily, _aggregate_monthly, _aggregate_weekly
+from _lib_pricing import _calculate_entry_cost, _chip_for_model, _short_model_name
+from _lib_five_hour import _canonical_5h_window_key
+from _lib_subscription_weeks import _compute_subscription_weeks
+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
+
+
 # === Module-level back-ref shims for helpers that STAY in bin/cctally ======
 # Each shim resolves ``sys.modules['cctally'].X`` at CALL TIME (not bind
 # time), so monkeypatches on cctally's namespace propagate into the moved
-# code unchanged. Mirrors the precedent established in
-# ``bin/_cctally_record.py`` (34 shims), ``bin/_cctally_cache.py``
-# (4 shims), ``bin/_cctally_db.py`` (4 shims), and
-# ``bin/_cctally_update.py`` (8 shims).
-def eprint(*args, **kwargs):
-    return sys.modules["cctally"].eprint(*args, **kwargs)
-
-
-def now_utc_iso(*args, **kwargs):
-    return sys.modules["cctally"].now_utc_iso(*args, **kwargs)
-
-
-def parse_iso_datetime(*args, **kwargs):
-    return sys.modules["cctally"].parse_iso_datetime(*args, **kwargs)
-
-
-def _now_utc(*args, **kwargs):
-    return sys.modules["cctally"]._now_utc(*args, **kwargs)
-
-
-def _command_as_of(*args, **kwargs):
-    return sys.modules["cctally"]._command_as_of(*args, **kwargs)
-
-
+# code unchanged. `load_config` and `get_claude_session_entries` STAY as
+# shims even though their natural homes are decentralized (_cctally_config
+# / _cctally_cache) — tests monkeypatch them via `ns["X"]` (21 sites total,
+# audited 2026-05-17); direct imports would silently bypass the patches.
+# See spec §3.5 (carve-out) and §3.7 (stays-on-shim allowlist).
 def load_config(*args, **kwargs):
     return sys.modules["cctally"].load_config(*args, **kwargs)
 
 
-def save_config(*args, **kwargs):
-    return sys.modules["cctally"].save_config(*args, **kwargs)
-
-
-def open_db(*args, **kwargs):
-    return sys.modules["cctally"].open_db(*args, **kwargs)
-
-
-def get_entries(*args, **kwargs):
-    return sys.modules["cctally"].get_entries(*args, **kwargs)
-
-
 def get_claude_session_entries(*args, **kwargs):
     return sys.modules["cctally"].get_claude_session_entries(*args, **kwargs)
 
 
-def get_latest_usage_for_week(*args, **kwargs):
-    return sys.modules["cctally"].get_latest_usage_for_week(*args, **kwargs)
-
-
-def make_week_ref(*args, **kwargs):
-    return sys.modules["cctally"].make_week_ref(*args, **kwargs)
-
-
-def format_display_dt(*args, **kwargs):
-    return sys.modules["cctally"].format_display_dt(*args, **kwargs)
-
-
-def resolve_display_tz(*args, **kwargs):
-    return sys.modules["cctally"].resolve_display_tz(*args, **kwargs)
-
-
-def normalize_display_tz_value(*args, **kwargs):
-    return sys.modules["cctally"].normalize_display_tz_value(*args, **kwargs)
-
-
-def _compute_display_block(*args, **kwargs):
-    return sys.modules["cctally"]._compute_display_block(*args, **kwargs)
-
-
-def _render_migration_error_banner(*args, **kwargs):
-    return sys.modules["cctally"]._render_migration_error_banner(*args, **kwargs)
-
-
-def _aggregate_daily(*args, **kwargs):
-    return sys.modules["cctally"]._aggregate_daily(*args, **kwargs)
-
-
-def _aggregate_monthly(*args, **kwargs):
-    return sys.modules["cctally"]._aggregate_monthly(*args, **kwargs)
-
-
-def _aggregate_weekly(*args, **kwargs):
-    return sys.modules["cctally"]._aggregate_weekly(*args, **kwargs)
-
-
-def _calculate_entry_cost(*args, **kwargs):
-    return sys.modules["cctally"]._calculate_entry_cost(*args, **kwargs)
-
-
-def _canonical_5h_window_key(*args, **kwargs):
-    return sys.modules["cctally"]._canonical_5h_window_key(*args, **kwargs)
-
-
-def _chip_for_model(*args, **kwargs):
-    return sys.modules["cctally"]._chip_for_model(*args, **kwargs)
-
-
-def _short_model_name(*args, **kwargs):
-    return sys.modules["cctally"]._short_model_name(*args, **kwargs)
-
-
-def _compute_subscription_weeks(*args, **kwargs):
-    return sys.modules["cctally"]._compute_subscription_weeks(*args, **kwargs)
-
-
-def _group_entries_into_blocks(*args, **kwargs):
-    return sys.modules["cctally"]._group_entries_into_blocks(*args, **kwargs)
-
-
-def _get_alerts_config(*args, **kwargs):
-    return sys.modules["cctally"]._get_alerts_config(*args, **kwargs)
-
-
 def _warn_alerts_bad_config_once(*args, **kwargs):
     return sys.modules["cctally"]._warn_alerts_bad_config_once(*args, **kwargs)
 
@@ -402,10 +336,6 @@ def doctor_gather_state(*args, **kwargs):
     return sys.modules["cctally"].doctor_gather_state(*args, **kwargs)
 
 
-def _load_config_unlocked(*args, **kwargs):
-    return sys.modules["cctally"]._load_config_unlocked(*args, **kwargs)
-
-
 def _apply_display_tz_override(*args, **kwargs):
     return sys.modules["cctally"]._apply_display_tz_override(*args, **kwargs)
 
@@ -2490,7 +2420,7 @@ def _select_current_block_for_envelope(
 
     block = conn.execute(
         """
-        SELECT block_start_at, last_observed_at_utc,
+        SELECT five_hour_window_key, block_start_at, last_observed_at_utc,
                seven_day_pct_at_block_start,
                crossed_seven_day_reset
           FROM five_hour_blocks
@@ -2539,11 +2469,41 @@ def _select_current_block_for_envelope(
         None if (p_anchor is None or current_used_pct is None)
         else round(current_used_pct - p_anchor, 9)
     )
+
+    # Spec §5.3 — in-place credit events for this 5h block's window,
+    # ascending by ``effective_reset_at_utc``. Drives the
+    # ``CurrentWeekPanel.tsx`` ``⚡ credited -Xpp`` chip and the
+    # ``CurrentWeekModal.tsx`` merged-stream 5h milestones section.
+    # Snake_case keys to match the envelope convention (see CLAUDE.md;
+    # CLI ``--json`` uses camelCase, dashboard envelope is snake_case).
+    cred_rows = conn.execute(
+        """
+        SELECT effective_reset_at_utc, prior_percent, post_percent
+          FROM five_hour_reset_events
+         WHERE five_hour_window_key = ?
+         ORDER BY effective_reset_at_utc ASC
+        """,
+        (int(block["five_hour_window_key"]),),
+    ).fetchall()
+    credits = [
+        {
+            "effective_reset_at_utc": c["effective_reset_at_utc"],
+            "prior_percent": float(c["prior_percent"]),
+            "post_percent": float(c["post_percent"]),
+            "delta_pp": round(
+                float(c["post_percent"]) - float(c["prior_percent"]), 1
+            ),
+        }
+        for c in cred_rows
+    ]
+
     return {
         "block_start_at":               block["block_start_at"],
+        "five_hour_window_key":         int(block["five_hour_window_key"]),
         "seven_day_pct_at_block_start": p_start,
         "seven_day_pct_delta_pp":       delta,
         "crossed_seven_day_reset":      crossed,
+        "credits":                      credits,
     }
 
 
@@ -2603,13 +2563,29 @@ def _build_alerts_envelope_array(
                 "week_start_date":     r["week_start_date"],
                 "cumulative_cost_usd": cumulative,
                 "dollars_per_percent": dpp,
+                # Round-3: parallel to the 5h context block below — both
+                # axes now expose ``reset_event_id`` so downstream
+                # clients (panel, modal, third-party consumers) can
+                # discriminate pre- vs post-credit crossings of the
+                # same (week, threshold) without scraping the
+                # envelope ``id`` string. 0 = pre-credit / no-event;
+                # event.id = post-credit segment.
+                "reset_event_id":      int(r["reset_event_id"]),
             },
         })
 
+    # Site F (spec §3.2 bucket C / §3.3): widen the row identity to
+    # include ``reset_event_id`` so post-credit (seg=event.id) crossings
+    # of the same (window_key, threshold) don't collide with pre-credit
+    # (seg=0) crossings on the React row key. Older clients tolerate
+    # longer ids — the id is opaque to them; only the React key
+    # uniqueness invariant matters. Mirrors the weekly precedent at
+    # line ~2597.
     fh_rows = conn.execute(
         """
         SELECT m.five_hour_window_key, m.percent_threshold, m.captured_at_utc,
-               m.alerted_at, m.block_cost_usd, b.block_start_at
+               m.alerted_at, m.block_cost_usd, m.reset_event_id,
+               b.block_start_at
         FROM five_hour_milestones m
         LEFT JOIN five_hour_blocks b ON b.five_hour_window_key = m.five_hour_window_key
         WHERE m.alerted_at IS NOT NULL
@@ -2621,7 +2597,10 @@ def _build_alerts_envelope_array(
     for r in fh_rows:
         threshold = int(r["percent_threshold"])
         out.append({
-            "id":          f"five_hour:{int(r['five_hour_window_key'])}:{threshold}",
+            "id":          (
+                f"five_hour:{int(r['five_hour_window_key'])}:"
+                f"{threshold}:{int(r['reset_event_id'])}"
+            ),
             "axis":        "five_hour",
             "threshold":   threshold,
             "crossed_at":  r["captured_at_utc"],
@@ -2630,6 +2609,7 @@ def _build_alerts_envelope_array(
                 "five_hour_window_key": int(r["five_hour_window_key"]),
                 "block_start_at":       r["block_start_at"] or "",
                 "block_cost_usd":       float(r["block_cost_usd"] or 0.0),
+                "reset_event_id":       int(r["reset_event_id"]),
             },
         })
 
@@ -2937,7 +2917,7 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
     alerts_array = list(getattr(snap, "alerts", []) or [])
     try:
         _alerts_cfg = _get_alerts_config(load_config())
-    except sys.modules["cctally"]._AlertsConfigError as exc:
+    except _AlertsConfigError as exc:
         _warn_alerts_bad_config_once(exc)
         _alerts_cfg = {
             "enabled": False,
@@ -3065,6 +3045,17 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
                     }
                     for m in (snap.percent_milestones or [])
                 ],
+                # Spec §5.3 (Codex r1 finding 3) — NEW envelope key
+                # parallel to ``milestones`` (which carries the WEEKLY
+                # timeline). 5h-block milestones for the active block,
+                # in capture-time order, both pre- and post-credit
+                # segments included (bucket B per §3.2 — no
+                # ``reset_event_id`` filter; the React layer renders
+                # repeated thresholds as distinct rows keyed on
+                # ``reset_event_id``). Empty list when no 5h block is
+                # bound or the data source crashed during sync
+                # (recorded on ``last_sync_error``).
+                "five_hour_milestones":     getattr(snap, "five_hour_milestones", []) or [],
             },
 
         "forecast":
@@ -3721,7 +3712,7 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
                 # save_config has not yet been called).
                 try:
                     _get_alerts_config(merged)
-                except sys.modules["cctally"]._AlertsConfigError as exc:
+                except _AlertsConfigError as exc:
                     self._respond_json(400, {"error": str(exc)})
                     return
 

package/bin/_cctally_db.py

@@ -71,35 +71,32 @@ def _cctally():
     return sys.modules["cctally"]
 
 
-# Module-level back-ref shims for the four callables most heavily used
-# across migration handlers + cmd_db_* renderers. Each shim resolves
-# `sys.modules['cctally'].X` at CALL TIME (not bind time), so
-# monkeypatches on cctally's namespace propagate into the moved code
-# unchanged. This lets the moved function bodies stay byte-identical
-# at every bare-name call site (`now_utc_iso(...)`,
-# `parse_iso_datetime(...)`, etc.) without requiring per-function
-# `c = _cctally()` boilerplate or `c.X` rewrites at every call site.
+# === Honest imports from extracted homes ===================================
+# Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3: kernel symbols
+# import from _cctally_core. The legacy shim functions for these names
+# are deleted.
+from _cctally_core import (
+    eprint,
+    now_utc_iso,
+    parse_iso_datetime,
+)
+
+
+# Module-level back-ref shim for the one Z-high callable that STAYS in
+# bin/cctally. Resolves `sys.modules['cctally'].X` at CALL TIME (not
+# bind time), so monkeypatches on cctally's namespace propagate into the
+# moved code unchanged. `_compute_block_totals` is Z-high (reaches into
+# _cctally_cache via get_claude_session_entries) and is explicitly listed
+# in spec §3.7's stays-on-shim allowlist.
 #
 # Path constants and rarer helpers (`MIGRATION_ERROR_LOG_PATH`,
 # `LOG_DIR`, `DB_PATH`, `CACHE_DB_PATH`, `format_local_iso`) are
 # accessed via the standard `c = _cctally()` + `c.X` pattern instead
 # (call-time lookup so fixture-HOME redirects propagate).
-def now_utc_iso(*args, **kwargs):
-    return sys.modules["cctally"].now_utc_iso(*args, **kwargs)
-
-
-def parse_iso_datetime(*args, **kwargs):
-    return sys.modules["cctally"].parse_iso_datetime(*args, **kwargs)
-
-
 def _compute_block_totals(*args, **kwargs):
     return sys.modules["cctally"]._compute_block_totals(*args, **kwargs)
 
 
-def eprint(*args, **kwargs):
-    return sys.modules["cctally"].eprint(*args, **kwargs)
-
-
 # === BEGIN MOVED REGIONS ===
 # Regions below are inserted verbatim from bin/cctally. Bare-name
 # references to `now_utc_iso(...)`, `parse_iso_datetime(...)`,
@@ -1009,36 +1006,65 @@ def _migration_merge_5h_block_duplicates_v1(conn: sqlite3.Connection) -> None:
 
             # (c) Milestones: per-threshold dedup, keep earliest
             # captured_at_utc, re-FK keepers to canonical.
+            #
+            # Defensive widening (Codex r2 finding 1, spec §3.4): if
+            # migration 006 has already landed and added ``reset_event_id``,
+            # key the dedup on ``(percent_threshold, reset_event_id)`` so
+            # we don't silently collapse legitimately distinct pre/post-
+            # credit rows at the same physical threshold. On the legacy
+            # upgrade path (column doesn't exist yet because 003 runs
+            # before 006 in migration order), ``has_seg`` is False and the
+            # dedup key collapses to ``(threshold, 0)`` — byte-identical
+            # to the original threshold-only shape. PRAGMA probe rather
+            # than version-detect so the path also covers operator
+            # re-runs (e.g. ``cctally db unskip 003_*``) post-006.
+            ms_cols = {
+                str(r[1])
+                for r in conn.execute(
+                    "PRAGMA table_info(five_hour_milestones)"
+                ).fetchall()
+            }
+            has_seg = "reset_event_id" in ms_cols
             ms_id_placeholders = ",".join(
                 "?" * (len(dropped_ids) + 1)
             )
-            all_milestones = conn.execute(
-                f"SELECT id, percent_threshold, captured_at_utc "
-                f"  FROM five_hour_milestones "
-                f" WHERE block_id IN ({ms_id_placeholders})",
-                [canonical["id"], *dropped_ids],
-            ).fetchall()
-            by_threshold: dict[int, dict] = {}
+            if has_seg:
+                all_milestones = conn.execute(
+                    f"SELECT id, percent_threshold, captured_at_utc, "
+                    f"       reset_event_id "
+                    f"  FROM five_hour_milestones "
+                    f" WHERE block_id IN ({ms_id_placeholders})",
+                    [canonical["id"], *dropped_ids],
+                ).fetchall()
+            else:
+                all_milestones = conn.execute(
+                    f"SELECT id, percent_threshold, captured_at_utc "
+                    f"  FROM five_hour_milestones "
+                    f" WHERE block_id IN ({ms_id_placeholders})",
+                    [canonical["id"], *dropped_ids],
+                ).fetchall()
+            by_key: dict[tuple[int, int], dict] = {}
             for m in all_milestones:
-                t = m["percent_threshold"]
+                seg = int(m["reset_event_id"]) if has_seg else 0
+                key = (int(m["percent_threshold"]), seg)
                 md = dict(m)
                 if (
-                    t not in by_threshold
+                    key not in by_key
                     or md["captured_at_utc"]
-                    < by_threshold[t]["captured_at_utc"]
+                    < by_key[key]["captured_at_utc"]
                 ):
-                    by_threshold[t] = md
-            keep_ids = {m["id"] for m in by_threshold.values()}
+                    by_key[key] = md
+            keep_ids = {m["id"] for m in by_key.values()}
             # DELETE non-keepers BEFORE rekeying keepers. Otherwise, when
             # both canonical and a dropped block hold a milestone for the
-            # same percent_threshold and the dropped row's milestone is
-            # the earlier keeper, UPDATEing it to the canonical key
-            # collides with canonical's still-present non-keeper on
-            # UNIQUE(five_hour_window_key, percent_threshold), rolling
-            # back the migration. After this DELETE the only milestones
-            # referencing dropped_keys are the keepers themselves
-            # (one per threshold), so the UPDATE loop below is collision-
-            # free.
+            # same physical key and the dropped row's milestone is the
+            # earlier keeper, UPDATEing it to the canonical key collides
+            # with canonical's still-present non-keeper on UNIQUE
+            # (either the 2-col legacy shape or the 3-col post-006 shape),
+            # rolling back the migration. After this DELETE the only
+            # milestones referencing dropped_keys are the keepers
+            # themselves (one per dedup key), so the UPDATE loop below is
+            # collision-free.
             non_keep_ids = [
                 m["id"] for m in all_milestones if m["id"] not in keep_ids
             ]
@@ -1049,7 +1075,7 @@ def _migration_merge_5h_block_duplicates_v1(conn: sqlite3.Connection) -> None:
                     f" WHERE id IN ({nk_placeholders})",
                     non_keep_ids,
                 )
-            for m in by_threshold.values():
+            for m in by_key.values():
                 conn.execute(
                     "UPDATE five_hour_milestones "
                     "   SET block_id = ?, "
@@ -1437,6 +1463,210 @@ def _migration_percent_milestones_reset_event_id(conn: sqlite3.Connection) -> No
         raise
 
 
+@stats_migration("006_five_hour_milestones_reset_event_id")
+def _migration_five_hour_milestones_reset_event_id(conn: sqlite3.Connection) -> None:
+    """Add ``reset_event_id`` to ``five_hour_milestones`` so post-credit
+    threshold crossings can coexist with pre-credit ones for the same
+    ``(five_hour_window_key, percent_threshold)``.
+
+    Sentinel: ``0`` = pre-credit / no event. Existing rows backfill to
+    ``0`` via the ``DEFAULT 0`` clause on the new column.
+
+    The new UNIQUE constraint is
+    ``UNIQUE(five_hour_window_key, percent_threshold, reset_event_id)`` so
+    the same (window_key, threshold) pair can land twice if a goodwill
+    credit re-opens the segment under a fresh ``five_hour_reset_events.id``.
+    SQLite can't ALTER a UNIQUE constraint in place — we use the
+    rename-recreate-copy idiom (same as migration 005 did for
+    ``percent_milestones``).
+
+    Companion live-path edits land at (Task 2 of issue #43):
+      - bin/_cctally_record.py — 5h milestone INSERT + alert paths
+        (Sites A-E in spec §3.3); grep ``active_reset_event_id`` to
+        locate (line numbers drift per ``gotcha_cited_line_numbers_stale``)
+      - bin/_cctally_dashboard.py — alerts list row-identity widening
+        (Site F in spec §3.3 — bucket C per spec §3.2's three-bucket model);
+        grep ``reset_event_id`` near the 5h alerts SELECT
+
+    Idempotent: a second invocation finds the column already present and
+    returns. Empty-table fast path: when the column is already present
+    (fresh-install fast-stamp from the dispatcher because the live
+    ``CREATE TABLE IF NOT EXISTS five_hour_milestones`` already carries
+    the new shape — REQUIRED for fresh-install correctness per spec §3.2),
+    the marker still gets stamped — no schema edit needed.
+    """
+    # Fast-path probe: column already present means a prior run of this
+    # migration (or a fresh-install fast-stamp from the dispatcher that
+    # already picked up the new live-schema CREATE TABLE) has done the
+    # work. Just stamp the marker and return. The marker INSERT runs in
+    # SQLite's implicit transaction (auto-opened by the write, closed by
+    # ``commit()`` — same shape as migration 005's fast path); no explicit
+    # ``BEGIN`` is needed for a single-statement DML.
+    cols = {
+        str(r[1])
+        for r in conn.execute("PRAGMA table_info(five_hour_milestones)").fetchall()
+    }
+    if "reset_event_id" in cols:
+        conn.execute(
+            "INSERT OR IGNORE INTO schema_migrations (name, applied_at_utc) "
+            "VALUES (?, ?)",
+            ("006_five_hour_milestones_reset_event_id", now_utc_iso()),
+        )
+        conn.commit()
+        return
+
+    conn.execute("BEGIN")
+    try:
+        # Add the column with sentinel 0 default (covers existing rows).
+        conn.execute(
+            "ALTER TABLE five_hour_milestones "
+            "ADD COLUMN reset_event_id INTEGER NOT NULL DEFAULT 0"
+        )
+        # SQLite can't ALTER a UNIQUE constraint in place; rename, recreate
+        # with the new 3-column UNIQUE, copy, drop. Preserves ids and every
+        # existing column (including those added by add_column_if_missing:
+        # alerted_at).
+        conn.execute(
+            "ALTER TABLE five_hour_milestones "
+            "RENAME TO five_hour_milestones_old_006"
+        )
+        conn.execute(
+            """
+            CREATE TABLE five_hour_milestones (
+                id                          INTEGER PRIMARY KEY AUTOINCREMENT,
+                block_id                    INTEGER NOT NULL,
+                five_hour_window_key        INTEGER NOT NULL,
+                percent_threshold           INTEGER NOT NULL,
+                captured_at_utc             TEXT    NOT NULL,
+                usage_snapshot_id           INTEGER NOT NULL,
+                block_input_tokens          INTEGER NOT NULL DEFAULT 0,
+                block_output_tokens         INTEGER NOT NULL DEFAULT 0,
+                block_cache_create_tokens   INTEGER NOT NULL DEFAULT 0,
+                block_cache_read_tokens     INTEGER NOT NULL DEFAULT 0,
+                block_cost_usd              REAL    NOT NULL DEFAULT 0,
+                marginal_cost_usd           REAL,
+                seven_day_pct_at_crossing   REAL,
+                alerted_at                  TEXT,
+                reset_event_id              INTEGER NOT NULL DEFAULT 0,
+                UNIQUE(five_hour_window_key, percent_threshold, reset_event_id),
+                FOREIGN KEY (block_id) REFERENCES five_hour_blocks(id)
+            )
+            """
+        )
+        conn.execute(
+            """
+            INSERT INTO five_hour_milestones (
+                id, block_id, five_hour_window_key, percent_threshold,
+                captured_at_utc, usage_snapshot_id,
+                block_input_tokens, block_output_tokens,
+                block_cache_create_tokens, block_cache_read_tokens,
+                block_cost_usd, marginal_cost_usd,
+                seven_day_pct_at_crossing, alerted_at, reset_event_id
+            )
+            SELECT id, block_id, five_hour_window_key, percent_threshold,
+                   captured_at_utc, usage_snapshot_id,
+                   block_input_tokens, block_output_tokens,
+                   block_cache_create_tokens, block_cache_read_tokens,
+                   block_cost_usd, marginal_cost_usd,
+                   seven_day_pct_at_crossing, alerted_at, reset_event_id
+              FROM five_hour_milestones_old_006
+            """
+        )
+        # Recreate the block_id index that was attached to the original
+        # table; the rename carried index metadata with the table, but
+        # the new table needs its own index entry. Safe under
+        # IF NOT EXISTS if the rename preserved it (it does in practice,
+        # but the explicit recreate is defensive).
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_five_hour_milestones_block
+            ON five_hour_milestones(block_id)
+            """
+        )
+        conn.execute("DROP TABLE five_hour_milestones_old_006")
+        conn.execute(
+            "INSERT OR IGNORE INTO schema_migrations (name, applied_at_utc) "
+            "VALUES (?, ?)",
+            ("006_five_hour_milestones_reset_event_id", now_utc_iso()),
+        )
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        raise
+
+
+@stats_migration("007_observed_pre_credit_pct")
+def _migration_observed_pre_credit_pct(conn: sqlite3.Connection) -> None:
+    """Add ``observed_pre_credit_pct`` to ``week_reset_events`` so the
+    race-defensive cleanup DELETE in the in-place weekly credit branch
+    has a durable record of the pre-credit baseline we observed at
+    write time — independent of how the upstream claude-statusline
+    tool rounds replays.
+
+    Today statusline replays cctally's ``hwm-7d`` value byte-identically,
+    so the existing strict ``round(.,1)`` equality predicate is sound.
+    Future-proofs against rounding drift: if Anthropic ever rounds the
+    ``--percent`` payload differently from the OAuth API used by
+    record-usage, or if statusline grows its own coarser rounding, a
+    replay at e.g. 67.5 against a stored prior_pct = 67.4 would slip
+    past strict equality and then dominate the reset-aware clamp's
+    MAX over the post-credit segment. With the value stamped on the
+    event row, the cleanup predicate widens to a 1.0pp tolerance band
+    (issue #45) — wide enough to absorb single-digit drift, narrow
+    enough that legitimate post-credit observations (≥25pp away by
+    the in-place credit detection threshold's hypothesis) stay.
+
+    Backfill: NULL on existing rows. NULL is legacy / never-stamped;
+    the live cleanup's bind still uses the current tick's in-scope
+    ``prior_pct`` (the value we just observed and would have stamped),
+    so the cleanup remains correct on the very tick that writes the
+    row. The stored value matters for future tooling that may re-run
+    cleanup against an already-written event row.
+
+    Companion live-path edits land in:
+      - bin/cctally — CREATE TABLE adds the column for fresh installs.
+      - bin/_cctally_record.py — in-place credit INSERT stamps
+        ``observed_pre_credit_pct = prior_pct``; race-defensive DELETE
+        switches from ``round(weekly_percent,1) = round(?,1)`` to
+        ``ABS(weekly_percent - ?) < 1.0``.
+
+    Idempotent: a second invocation finds the column already present
+    and returns. Empty-column fast path: when the live CREATE TABLE
+    already carries the column (fresh install), stamp the marker and
+    return without an ALTER. Simple ADD COLUMN — no UNIQUE constraint
+    change, so no rename-recreate-copy needed (contrast migrations
+    005 / 006).
+    """
+    cols = {
+        str(r[1])
+        for r in conn.execute("PRAGMA table_info(week_reset_events)").fetchall()
+    }
+    if "observed_pre_credit_pct" in cols:
+        conn.execute(
+            "INSERT OR IGNORE INTO schema_migrations (name, applied_at_utc) "
+            "VALUES (?, ?)",
+            ("007_observed_pre_credit_pct", now_utc_iso()),
+        )
+        conn.commit()
+        return
+
+    conn.execute("BEGIN")
+    try:
+        conn.execute(
+            "ALTER TABLE week_reset_events "
+            "ADD COLUMN observed_pre_credit_pct REAL"
+        )
+        conn.execute(
+            "INSERT OR IGNORE INTO schema_migrations (name, applied_at_utc) "
+            "VALUES (?, ?)",
+            ("007_observed_pre_credit_pct", now_utc_iso()),
+        )
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        raise
+
+
 # === Region 8: Test-only migration registration (was bin/cctally:12086-12140) ===
 
 # ──────────────────────────────────────────────────────────────────────