cctally 1.105.0 → 1.106.0

package/CHANGELOG.md

@@ -5,6 +5,38 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.106.0] - 2026-09-03
+
+### Changed
+- `cctally record-credit --force` replaces the single credit `--at` names instead of clearing the whole week, and refuses when `--at` names none. Recording a second credit in one week needs no `--force`: rerun with a different `--at`.
+- A week Anthropic credited in place renders as one row on its own boundaries, instead of two rows split at the credit. A credit that also moved the week's declared end is marked, but still renders on the windows the API stated.
+- The dashboard's Current Week header and modal name the week's own boundaries on a credited week, instead of the window that starts at the credit.
+- A credited week's row is marked `+` in `cctally report` and `cctally weekly`, so a low `Used %` beside a week's worth of spend has a visible explanation.
+- The dashboard's Weekly panel and its week detail mark a credited week, and the week detail, the Current Week card and its modal name why `$/1%` is withheld instead of the em-dash or `$0.000` you cannot tell from a week with no usage.
+- The dashboard's `$/1%` tables — the Weekly modal's week list, the `$/1% Trend` panel and its modal — say `No climb` for a credited week whose ratio is withheld, instead of the em-dash you cannot tell from a week with no usage.
+- `$/1%` for a credited week is measured from the credit forward, over the climb since it. With no climb yet the figure is withheld and names why. Uncredited weeks are unchanged.
+- The dashboard's Current Week card, the TUI header and a shared Current Week recap report a credited week's whole spend, matching the week they name and the Weekly card beside them. Only `$/1%` is measured from the credit forward.
+- `cctally milestone` history lists a credited week once instead of once per credit, and its detail separates the week's percent ladders with a row naming each credit and the level it dropped from.
+
+### Fixed
+- A conversation open in the viewer updates its own cost as its turns stream, for both Claude and Codex. The live tail advanced the transcript but not the accounting the cost is read from.
+- A Codex conversation's cost no longer reads `$0.00` long after its turns finish. The dashboard now re-scans each provider at least every two minutes, so accounting stays current even when that provider's activity hooks never fire.
+- Upgrading an existing installation to v1.105.0 left every background sync failing and the dashboard stuck on `server sync error`. The two columns that release added now reach an existing database, not only a freshly created one.
+- After Anthropic zeroes your weekly counter, every 7d surface lowers on the next status-line tick. A reading captured in the same hour no longer holds the week at its pre-credit percentage, and no manual command is needed.
+- A goodwill credit to a non-zero level records that level's own percent milestone. Before, the ladder for the new period opened one percent late, and `cctally percent-breakdown` was missing its first row.
+- `cctally percent-breakdown`, the TUI's milestone panel and the milestone writer agree on which credit a percent belongs to, including after a database rebuild and for a credit recorded with `cctally record-credit`.
+- A percent milestone crossed after a credit reports the cost spent since that credit. After a credit recorded with `cctally record-credit` it reported the whole week's spend, which made the first post-credit `$/1%` figure far too high.
+- `cctally record-credit` no longer deletes genuine usage recorded between the moment you assert with `--at` and the moment you run the command.
+- On an install with more than one Claude account, a reset detected for one account no longer records a credit for another, and no longer discards the first account's pending detection.
+- `cctally forecast` measures its rate from the latest credit rather than across it, including one you recorded yourself. `cctally budget` keeps summing the whole week, because the money was spent inside one unchanged window.
+- `cctally doctor`'s post-credit milestone check now sees a week credited with `cctally record-credit`, which it silently skipped before.
+- `cctally record-credit` accepts a second credit inside the same hour as the first. Only a credit at the identical instant is still refused, because that is indistinguishable from running the command twice.
+- An install upgrading from a version that predates the append-only journal now gets the current weekly-credit table shape, instead of reporting the new database version while missing the columns a credit needs.
+- `cctally record-credit --force` no longer leaves a replaced credit's percent milestones behind after a database rebuild, and `cctally record-usage` no longer leaves a removed stale reading's five-hour milestones pointing at it.
+- `cctally` no longer records a second, automatically-shaped credit for a large credit you already recorded with `cctally record-credit`.
+- A stale pre-credit reading replayed by the status line after a credit is removed on the next tick that contradicts it, instead of holding every 7d surface at the old percentage and provoking a second, phantom credit.
+- On an install with more than one Claude account, `cctally record-credit` no longer names another account's credit when refusing, and no longer finishes another account's interrupted credit as though it were yours.
+
 ## [1.105.0] - 2026-09-02
 
 ### Added

package/bin/_cctally_core.py

@@ -410,7 +410,21 @@ _init_paths_from_env()
 # install and the table would simply never appear. `quota_alert_arming` is the
 # precedent the family follows — a journaled STATE record whose boundary
 # survives a rebuild, so history cannot re-fire.
-STATS_INDEX_EPOCH = 1011
+# 1011 -> 1012 (#703 + #707): the unified Anthropic credit record. Adds the six
+# `week_reset_events` fact columns (`week_start_date`, `observed_at_utc`,
+# `confirming_capture_at_utc`, `observed_post_credit_pct`, `credit_key`,
+# `credit_order`) and relaxes `old_week_end_at` / `new_week_end_at` to NULL. On
+# a store ABOVE `LEGACY_STATS_HEAD` the bump alone delivers all of that, because
+# an epoch mismatch resolves by rebuilding the disposable index from the journal
+# against the new DDL. A PRE-CUTOVER store at `user_version <= 13` takes the
+# in-place cutover path instead and reaches this epoch with its existing table
+# untouched, so that path additionally runs the rename-recreate-copy in
+# `begin_week_reset_events_reshape` / `finish_week_reset_events_reshape`.
+# It is an epoch bump and NOT a stats migration for the two reasons every
+# bump since 1005 carries: the 13-entry registry is frozen, AND an epoch-current
+# open returns before any schema work, so a `@stats_migration` handler would
+# never run on an upgraded install and the columns would simply never appear.
+STATS_INDEX_EPOCH = 1012
 LEGACY_STATS_HEAD = 13
 
 #: #496 S1 F1. A NEW branch, for a state that cannot occur before the
@@ -1783,6 +1797,8 @@ def open_db(*, _target_path=None) -> sqlite3.Connection:
     # Enforced by tests/test_kernel_extraction_invariants.py
     # test_core_accessor_use_is_bounded (lands in I2).
     add_column_if_missing = c.add_column_if_missing
+    _begin_week_reset_events_reshape = c.begin_week_reset_events_reshape
+    _finish_week_reset_events_reshape = c.finish_week_reset_events_reshape
     _canonical_5h_window_key = c._canonical_5h_window_key
     _backfill_week_reset_events = c._backfill_week_reset_events
     _backfill_five_hour_blocks = c._backfill_five_hour_blocks
@@ -2217,23 +2233,111 @@ def open_db(*, _target_path=None) -> sqlite3.Connection:
         # start — preventing the API's -7d-derived new week from overlapping
         # the old week. Inserted by cmd_record_usage on detection; read by
         # _apply_reset_events_to_weekrefs and the cost live-recompute path.
+        # #703 + #707: this table is now the SINGLE durable representation of an
+        # Anthropic weekly credit, and it defines an accounting epoch only —
+        # never a display boundary. The six fact columns below are declared HERE
+        # rather than added by `add_column_if_missing`, because this is an epoch
+        # bump: an epoch-current open returns before any schema work, so a
+        # conditional column addition would never run on an upgraded install.
+        #
+        # The epoch bump alone covers only ONE of the two upgrade paths. A store
+        # ABOVE `LEGACY_STATS_HEAD` defers to a rebuild that materializes a fresh
+        # scratch index through this DDL, so it arrives correct. A PRE-CUTOVER
+        # store at `user_version <= 13` reaches this line with the table already
+        # present, where `CREATE TABLE IF NOT EXISTS` is a no-op; the cutover
+        # below then stamps the new epoch in place and every later open
+        # fast-returns before any schema work. `begin_week_reset_events_reshape`
+        # parks such a table aside so this CREATE builds the current shape, and
+        # `finish_week_reset_events_reshape` (right after the `account_key`
+        # guard) copies the rows back and drops the parked table. Without it the
+        # store reports the current epoch while missing every fact column and
+        # keeping both NOT NULL boundaries, which no later open can repair.
+        #
+        #   week_start_date            the week the credit belongs to, so the
+        #                              unified table is queryable by week without
+        #                              going through a boundary column.
+        #   observed_at_utc            the exact instant the post-credit state was
+        #                              first observed, in the SAME clock domain as
+        #                              `weekly_usage_snapshots.captured_at_utc`
+        #                              (the column it filters). NOT the detection
+        #                              clock — the ingest path separates the two,
+        #                              and comparing across the domains back-dates
+        #                              the epoch (the #703 incident).
+        #   confirming_capture_at_utc  the capture instant of the observation that
+        #                              confirmed the credit; closes the upper end
+        #                              of the automatic stale-replica bracket.
+        #   observed_post_credit_pct   where the counter landed.
+        #   credit_key                 the row's durable identity, derived from the
+        #                              SOURCE journal record and never from the
+        #                              boundaries. Several credits per week are
+        #                              representable because of it.
+        #   credit_order               that same source record's own journal
+        #                              instant, in Unix epoch seconds. NOT the
+        #                              absolute journal sequence position: that
+        #                              numbering exists but returns None on many
+        #                              ordinary ticks, and a durable column cannot
+        #                              be populated by something sometimes
+        #                              unavailable. NOT the fold position of the
+        #                              derived row either — a fold order expresses
+        #                              dependency, not occurrence. The instant is
+        #                              a fact OF THE SOURCE RECORD, so a rebuild
+        #                              reproduces it byte-identically and it orders
+        #                              by occurrence. Two known losses, both
+        #                              deliberate: two source instants inside one
+        #                              second tie and fall through to
+        #                              `credit_key DESC`, which is content-hash
+        #                              rather than chronological order; and under a
+        #                              backward clock step instant order and append
+        #                              order disagree.
+        #
+        # `old_week_end_at` / `new_week_end_at` are legacy provenance now and are
+        # NULLABLE: a cutover-exported `weekly_credit_floor` op cannot supply them
+        # (`weekly_credit_floors` retains no week-end timestamp), and NULL is the
+        # honest value for a row that never had them. NULL on any new column means
+        # the row predates this change or its source genuinely lacked the fact;
+        # every accounting read falls back through
+        # COALESCE(observed_at_utc, effective_reset_at_utc).
+        _wre_reshaping = _begin_week_reset_events_reshape(conn)
         conn.execute(
             """
             CREATE TABLE IF NOT EXISTS week_reset_events (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 detected_at_utc        TEXT NOT NULL,
-                old_week_end_at        TEXT NOT NULL,
-                new_week_end_at        TEXT NOT NULL,
+                old_week_end_at        TEXT,
+                new_week_end_at        TEXT,
                 effective_reset_at_utc TEXT NOT NULL,
                 observed_pre_credit_pct REAL,
                 account_key TEXT NOT NULL DEFAULT 'unattributed',
-                UNIQUE(account_key, old_week_end_at, new_week_end_at)
+                week_start_date           TEXT,
+                observed_at_utc           TEXT,
+                confirming_capture_at_utc TEXT,
+                observed_post_credit_pct  REAL,
+                credit_key                TEXT,
+                credit_order              INTEGER,
+                -- Identity is the SOURCE record, not the boundaries. Keyed on
+                -- the boundary pair, a second credit in one week had nowhere to
+                -- live: two credits inside one hour collide outright, because
+                -- `effective_reset_at_utc` is hour-floored. `credit_key` is NULL
+                -- for a row that predates this change, and SQLite treats NULLs
+                -- as distinct under UNIQUE, so legacy rows neither collide with
+                -- each other nor with a keyed one. Replay idempotence does not
+                -- rest on this constraint either way: every fold inserts with
+                -- `journal_id` set, and that column carries its own partial
+                -- UNIQUE index.
+                UNIQUE(account_key, credit_key)
             )
             """
         )
         add_column_if_missing(
             conn, "week_reset_events", "account_key",
             "TEXT NOT NULL DEFAULT 'unattributed'")
+        if _wre_reshaping:
+            # `journal_id` is added here rather than by the loop further down so
+            # the copy can carry it: a parked row's logical identity must reach
+            # the new table, or harvest would re-emit every already-journaled
+            # credit as a fresh `wr:` event. The loop below then no-ops on it.
+            add_column_if_missing(conn, "week_reset_events", "journal_id", "TEXT")
+            _finish_week_reset_events_reshape(conn)
         _backfill_week_reset_events(conn)
 
         # ── five_hour_reset_events (Anthropic-issued in-place 5h credits) ──
@@ -3064,9 +3168,8 @@ def _reset_aware_floor(
     *,
     account_key: str | None,
 ) -> str | None:
-    """Return the latest in-week clamp floor (an ISO timestamp) across BOTH
-    `week_reset_events` and `weekly_credit_floors`, or None when neither has a
-    row for this week.
+    """Return the latest in-week accounting floor (an ISO timestamp), or None
+    when this week has no credit.
 
     ``account_key`` (#341, review finding 11): MANDATORY account context — no
     silent global fallback. A real key scopes both legs to that account's
@@ -3075,40 +3178,68 @@ def _reset_aware_floor(
     analytics floor path, byte-identical to today on a single-account install.
 
     This is the single chokepoint the four MAX-clamp sites consult to floor the
-    current 7d % to the most-recent in-place credit / reset effective moment
+    current 7d % to the most-recent in-place credit / reset moment
     (record-credit M2, issue #209, spec §4a):
       - statusline `_hwm_clamp` 7d (bin/_cctally_statusline.py)
       - the record-usage write-site monotonic clamp (bin/_cctally_record.py)
       - `_resolve_reset_aware_hwm` (the --from default helper)
       - `project`'s `_load_week_snapshots` per-week MAX (bin/_cctally_project.py)
 
-    A `week_reset_events` row counts iff its `effective_reset_at_utc` falls in
-    `[week_start_at, week_end_at)`; a `weekly_credit_floors` row counts iff its
-    `week_start_date` matches (record-credit always stamps `effective_at_utc`
-    inside the week, validated at plan-build time).
+    #703 + #707 §5.3: the floor is ``COALESCE(observed_at_utc,
+    effective_reset_at_utc)``, NOT the effective instant. The effective instant
+    is hour-floored and display-only, and that rounding is what back-dated the
+    2026-09-01 incident's epoch: the credit was first observed at 17:59:41, the
+    row recorded 17:00:00, and a genuine 13.0 snapshot captured at 17:33:38 fell
+    inside the accounting window, held the maximum, and made every later genuine
+    reading look like a regression. NULL on the exact instant means the row
+    predates this change, and such a row keeps the only instant it has.
+
+    A row counts iff it belongs to this WEEK. That is `week_start_date` for a
+    row that records it, and the `[week_start_at, week_end_at)` range only for a
+    row that predates the column. The range alone is a narrowing this helper
+    must not inherit from the reset-event leg it replaces: the display layer
+    overrides `week_start_at` to a credit's own effective instant, so an EARLIER
+    credit in the same week falls outside the range the caller passes. The
+    `weekly_credit_floors` leg this collapses had no time bound at all and found
+    it; keying on the week's identity keeps that.
+
+    The `weekly_credit_floors` leg is retained for exactly one state and is
+    otherwise dead. The in-place cutover EXPORTS that table to a bootstrap
+    segment and stamps `journal_id` on its rows, but it does not re-fold them,
+    so between a legacy store's cutover and its first rebuild the credit exists
+    only there. Nothing writes the table any more — the `weekly_credit_floor` op
+    folds into `week_reset_events` — and a rebuilt index does not carry the rows
+    at all, so on every other store this leg matches nothing. It cannot lower a
+    floor either: for one credit present in both tables the unified row's exact
+    instant is at or after the floored one, and the latest wins.
 
     The latest floor wins via `ORDER BY unixepoch(floor_at) DESC LIMIT 1` —
-    `unixepoch()`, NOT a textual `MAX(...)`: the two legs carry mixed offset
+    `unixepoch()`, NOT a textual `MAX(...)`: the legs carry mixed offset
     spellings (`Z` / `+00:00`), and a lexical MAX would silently mis-order them
     on a non-UTC host (the same gotcha as the statusline clamp / 5h-block
     cross-reset flag; see the comment at bin/_cctally_statusline.py)."""
     acct_pred = "" if account_key is None else " AND account_key = ?"
-    reset_params: tuple = (week_start_at, week_end_at) + (
-        () if account_key is None else (account_key,))
-    floor_params: tuple = (week_start_date,) + (
-        () if account_key is None else (account_key,))
+    acct_param: tuple = () if account_key is None else (account_key,)
+    reset_params: tuple = (
+        (week_start_date, week_start_at, week_end_at) + acct_param)
+    floor_params: tuple = (week_start_date,) + acct_param
     row = conn.execute(
         f"""
         SELECT floor_at FROM (
-            SELECT effective_reset_at_utc AS floor_at
+            SELECT COALESCE(observed_at_utc, effective_reset_at_utc) AS floor_at
               FROM week_reset_events
-             WHERE unixepoch(effective_reset_at_utc) >= unixepoch(?)
-               AND unixepoch(effective_reset_at_utc) <  unixepoch(?){acct_pred}
+             WHERE (
+                     week_start_date = ?
+                     OR (week_start_date IS NULL
+                         AND unixepoch(effective_reset_at_utc) >= unixepoch(?)
+                         AND unixepoch(effective_reset_at_utc) <  unixepoch(?))
+                   ){acct_pred}
             UNION ALL
             SELECT effective_at_utc AS floor_at
               FROM weekly_credit_floors
              WHERE week_start_date = ?{acct_pred}
         )
+        WHERE floor_at IS NOT NULL
         ORDER BY unixepoch(floor_at) DESC
         LIMIT 1
         """,

package/bin/_cctally_dashboard.py

@@ -510,15 +510,12 @@ from _cctally_cache import (
 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,
 )
@@ -3623,19 +3620,20 @@ 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,
-                                    use_bugk_segment_cache: bool = False) -> "list[WeeklyPeriodRow]":
+                                    use_group_a_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
-    ``view.rows``. ``build_weekly_view`` (in ``bin/_lib_view_models.py``)
-    owns the bucket+overlay walk — this function calls it, swaps two
-    presentation fields (``label`` ← ``display_start_date`` for post-
-    early-reset weeks; ``is_current`` ← SubWeek-containing-now_utc with
-    snapshot fallback so the "Now" pill tracks wall time), layers Bug-K
-    pre-credit synthesized rows over the natural rows, then recomputes
-    ``delta_cost_pct`` newest-first so the synthesized rows participate
-    in the deltas.
+    Thin builder-using prelude on top of ``view.rows``. ``build_weekly_view``
+    (in ``bin/_lib_view_models.py``) owns the bucket+overlay walk — this
+    function calls it, swaps two presentation fields (``label`` ←
+    ``display_start_date`` for post-early-reset weeks; ``is_current`` ←
+    SubWeek-containing-now_utc with snapshot fallback so the "Now" pill tracks
+    wall time), then computes ``delta_cost_pct`` newest-first.
+
+    It used to layer a synthesized pre-credit row over the natural rows, because
+    the credited week's own row covered only the post-credit interval. #703 +
+    #707 §6.1 removed both halves of that: an Anthropic reset never changes the
+    week's boundaries, so the natural row already covers the whole week.
 
     Note: weekly bucketing intentionally does NOT take ``display_tz`` —
     SubWeek bucket keys come from server-anchored stored anchors and the
@@ -3749,219 +3747,14 @@ def _dashboard_build_weekly_periods(conn: "sqlite3.Connection",
         r.delta_cost_pct = None
         rows_oldest_first.append(r)
 
-    # Bug K (v1.7.2 round-5): synthesize a pre-credit segment row for
-    # each in-place credit event. Without this the credited week shows
-    # ONLY the post-credit segment ($134 on live data) and the bulk of
-    # the week's cost (~$372 in entries before the credit moment) is
-    # invisible to the user.
-    #
-    # _apply_reset_events_to_subweeks shifts the credited SubWeek's
-    # start_ts to ``effective_reset_at_utc``, so _aggregate_weekly's
-    # bucket for that SubWeek already covers ONLY the post-credit
-    # interval. We rebuild the pre-credit bucket here by fetching the
-    # ``[original_start, effective)`` window directly (#268: no longer a
-    # wide ``entries`` list on the cached path) and re-aggregating cost /
-    # tokens / per-model.
-    #
-    # The pre-credit row's ``used_pct`` comes from the
-    # weekly_usage_snapshots row captured at-or-before the credit
-    # moment (the pre-credit peak the user reached); fall back to None
-    # if no snapshot was recorded before the credit fired.
-    in_place_credits = conn.execute(
-        "SELECT new_week_end_at, effective_reset_at_utc "
-        "FROM week_reset_events "
-        "WHERE old_week_end_at = effective_reset_at_utc"
-    ).fetchall()
-    if in_place_credits:
-        _lib_pricing = sys.modules.get("_lib_pricing")
-        if _lib_pricing is None:
-            import importlib.util as _ilu, pathlib as _pl
-            _p = _pl.Path(__file__).resolve().parent / "_lib_pricing.py"
-            _spec = _ilu.spec_from_file_location("_lib_pricing", _p)
-            _lib_pricing = _ilu.module_from_spec(_spec)
-            sys.modules["_lib_pricing"] = _lib_pricing
-            _spec.loader.exec_module(_lib_pricing)
-        _calc = _lib_pricing._calculate_entry_cost
-
-        insertions: list[tuple[int, WeeklyPeriodRow]] = []
-        for ev in in_place_credits:
-            try:
-                eff_dt = parse_iso_datetime(
-                    ev["effective_reset_at_utc"], "credit.eff"
-                )
-                new_end_dt = parse_iso_datetime(
-                    ev["new_week_end_at"], "credit.new_end"
-                )
-            except ValueError:
-                continue
-            # Find the SubWeek whose end_ts equals new_week_end_at (the
-            # post-credit segment); its start_ts has already been
-            # shifted to ``effective`` by _apply_reset_events_to_subweeks.
-            post_sw = None
-            for w in weeks:
-                try:
-                    w_end = parse_iso_datetime(w.end_ts, "sw.end")
-                except ValueError:
-                    continue
-                if w_end == new_end_dt:
-                    post_sw = w
-                    break
-            if post_sw is None:
-                continue
-
-            # Original start instant: take the EARLIEST recorded
-            # week_start_at for this week_start_date. The post-credit
-            # SubWeek's start_ts is the shifted value (= effective); the
-            # MIN over weekly_usage_snapshots gives us the original
-            # API-derived start before the override fired.
-            orig_row = conn.execute(
-                "SELECT MIN(week_start_at) AS ws "
-                "FROM weekly_usage_snapshots "
-                "WHERE week_start_date = ? AND week_start_at IS NOT NULL",
-                (post_sw.start_date.isoformat(),),
-            ).fetchone()
-            if orig_row is None or orig_row["ws"] is None:
-                continue
-            try:
-                original_start_iso = str(orig_row["ws"])
-                original_start_dt = parse_iso_datetime(
-                    original_start_iso, "credit.original_start"
-                )
-            except ValueError:
-                continue
-            if original_start_dt >= eff_dt:
-                # No pre-credit interval to aggregate.
-                continue
-
-            # Aggregate entries in [original_start, effective). Fetch this
-            # window directly (skip_sync=True — the rebuild already ingested,
-            # 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.
-            #
-            # #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
-
-            # Pre-credit used_pct: latest snapshot at-or-before the
-            # credit moment for this week_start_date.
-            pre_usage = conn.execute(
-                "SELECT weekly_percent FROM weekly_usage_snapshots "
-                "WHERE week_start_date = ? "
-                "  AND unixepoch(captured_at_utc) <= unixepoch(?) "
-                "ORDER BY captured_at_utc DESC, id DESC LIMIT 1",
-                (post_sw.start_date.isoformat(), ev["effective_reset_at_utc"]),
-            ).fetchone()
-            pre_used_pct: float | None = None
-            if pre_usage is not None and pre_usage["weekly_percent"] is not None:
-                pre_used_pct = float(pre_usage["weekly_percent"])
-            pre_dpp = (
-                pre_cost / pre_used_pct
-                if pre_used_pct and pre_used_pct > 0 else None
-            )
-
-            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, key=lambda kv: -kv[1])
-            ]
-            pre_label = original_start_dt.strftime("%m-%d")
-            pre_row = WeeklyPeriodRow(
-                label=pre_label,
-                cost_usd=pre_cost,
-                total_tokens=pre_total,
-                input_tokens=pre_input,
-                output_tokens=pre_output,
-                cache_creation_tokens=pre_cc,
-                cache_read_tokens=pre_cr,
-                used_pct=pre_used_pct,
-                dollar_per_pct=pre_dpp,
-                delta_cost_pct=None,
-                # Pre-credit segment is historical even though it
-                # shares the bucket date with the live week.
-                is_current=False,
-                models=_model_breakdowns_to_models(
-                    pre_model_breakdowns, pre_cost
-                ),
-                week_start_at=original_start_iso,
-                week_end_at=ev["effective_reset_at_utc"],
-            )
-
-            # Find post-credit row's index and insert pre-credit BEFORE
-            # it (chronological order: pre then post in oldest-first).
-            post_idx = None
-            for i, r in enumerate(rows_oldest_first):
-                if r.week_start_at == post_sw.start_ts and r.week_end_at == post_sw.end_ts:
-                    post_idx = i
-                    break
-            if post_idx is None:
-                # The post-credit row may have been dropped by
-                # _aggregate_weekly (no entries in the post-credit
-                # interval) — append at the most-recent slot so the
-                # pre-credit segment still surfaces.
-                insertions.append((len(rows_oldest_first), pre_row))
-            else:
-                insertions.append((post_idx, pre_row))
-
-        # Apply insertions in REVERSE index order so prior insertions
-        # don't shift the indices of later ones.
-        for idx, pre_row in sorted(insertions, key=lambda t: -t[0]):
-            rows_oldest_first.insert(idx, pre_row)
+    # #703 + #707 §6.1: the pre-credit segment row is gone. It existed because
+    # `_apply_reset_events_to_subweeks` shifted the credited week's `start_ts`
+    # to the credit moment, so the panel's bucket covered only the post-credit
+    # interval and the bulk of the week's spend was invisible. That shift is
+    # gone — an Anthropic reset never changes the week's boundaries — so the
+    # single row already covers the whole week and a second one would double it.
+    # The credit still shows: the row carries the marker §6.4 describes, and the
+    # accounting segments remain in the milestone and drill-down data.
 
     # Reverse so caller gets newest-first; compute delta_cost_pct vs the
     # immediately older row in that orientation.

package/bin/_cctally_dashboard_conversation.py

@@ -53,6 +53,7 @@ import time
 from _cctally_cache import (
     open_cache_db,
     scope_conversations_db_to_account,
+    sync_cache,
     sync_codex_cache,
     sync_claude_conversations,
     sync_codex_conversations,
@@ -64,6 +65,38 @@ from _lib_dashboard_json import (
 )
 from _lib_retained_size import retained_size_bytes
 
+
+def _advance_live_tail_accounting(handler, changed, sync, label):
+    """Advance the accounting cache for paths a live tail just saw grow.
+
+    A conversation's rendered cost comes from the accounting store -- Claude
+    turns from ``session_entries``, Codex from ``codex_session_entries`` -- and
+    the periodic dashboard tick owns it.  A tail that advanced only the
+    transcript therefore streamed new turns whose cost stayed frozen at the last
+    ordinary tick's value, which reads as ``$0.00`` for a whole session whenever
+    that tick was certified caught up.  The ingest is targeted at exactly the
+    paths the tail resolved as changed, so this costs one file, never a walk.
+
+    Cost is an enhancement to the stream and never a precondition for it: a
+    contended or failed accounting write is logged and the transcript still
+    advances, because stalling the turns a reader is watching is strictly worse
+    than showing them beside a stale figure.  Callers that genuinely depend on
+    the accounting result -- the account-scoped Codex tail, which needs the
+    physical account-range decision committed before transcript ingest -- must
+    do their own ordered sync instead of calling this.
+    """
+    try:
+        accounting = open_cache_db()
+        try:
+            sync(accounting, only_paths=set(changed))
+        finally:
+            accounting.close()
+    except Exception as exc:  # noqa: BLE001
+        handler.log_error(
+            "api/conversation/events %s accounting sync failed: %r",
+            label, exc,
+        )
+
 # Live-tail watch-loop tuning — used ONLY by _handle_get_conversation_events_impl
 # below, so moved here with the events handler (spec §4.1 / §6).
 _LIVE_TAIL_POLL_INTERVAL = 1.0      # seconds between stat polls of the open file(s)
@@ -1104,6 +1137,7 @@ def _bare_conversation_events(
         return cq.session_source_paths(conn, session_id) if conn else []
 
     def _ingest(changed):
+        _advance_live_tail_accounting(handler, changed, sync_cache, "claude")
         if account_key is None:
             return sync_claude_conversations(conn, only_paths=set(changed))
         before = conn.execute(
@@ -1274,6 +1308,8 @@ def _qualified_conversation_events(
 
         def _ingest(changed):
             if account_key is None:
+                _advance_live_tail_accounting(
+                    handler, changed, sync_codex_cache, "codex")
                 return sync_codex_conversations(conn, only_paths=set(changed))
             before = conn.execute(
                 "SELECT COUNT(*),MAX(id) FROM codex_conversation_messages "
@@ -1317,6 +1353,8 @@ def _qualified_conversation_events(
             return cq.session_source_paths(conn, native)
 
         def _ingest(changed):
+            _advance_live_tail_accounting(
+                handler, changed, sync_cache, "claude")
             if account_key is None:
                 return sync_claude_conversations(conn, only_paths=set(changed))
             before = conn.execute(