cctally 1.22.3 → 1.22.4

package/CHANGELOG.md

@@ -5,6 +5,14 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.22.4] - 2026-06-01
+
+### Fixed
+- **A surprise mid-week Anthropic usage reset is now reflected in the 7d percentage even when you were below ~25% usage.** When Anthropic zeroes the weekly counter mid-window (same reset timestamp, usage drops to ~0 — e.g. the 2026-06-01 incident), the reset detector previously only fired when the drop was at least 25 percentage points, so any account reset from a lower base (the observed 14% → 0%) slipped through: no `week_reset_events` row was written, the monotonic high-water-mark clamp kept reporting the stale pre-reset percentage across the statusline, `weekly`/`report`, and the dashboard, and post-reset 0% reads were silently dropped at the write site. The detector now ALSO fires on a reset-to-zero — when the post-reset value collapses to ~0 (≤ 1%) with at least a 3pp drop — independently of the 25pp magnitude gate, since a clean drop to zero is an unambiguous reset regardless of size (a lagging API replica reports a slightly-lower number, never a clean 0 against real usage), while the 3pp floor rejects 1%→0% replica jitter that would otherwise spuriously segment the week. The new discriminator is a single shared `_is_reset_drop()` helper wired into all four 7d detection sites (live + backfill, boundary-advance + in-place-credit branches) so they stay byte-identical; the 25pp partial-credit path and the separate 5h detector are unchanged. Regression: three new cases in `tests/test_in_place_credit_detection.py` (live reset-to-zero fires below 25pp, the 3pp floor rejects 1%→0% jitter, and backfill parity).
+
+### Changed
+- **Internal refactor (no user-facing change): extracted the shared formatting/color/table render primitives — the boxed-table renderer, the color/unicode capability detectors, the ANSI styling + display-width helpers, the integer/width-budget number formatters, the compact timestamp/week-window formatters, and the `_ANSI_ESC_RE` regex (plus the small `_parse_iso_datetime_optional` helper they depend on) — out of the `bin/cctally` single-file program into a new stdlib-only pure-function sibling module, `bin/_lib_fmt.py` (#126, the final tranche of the `bin/cctally` split).** This trims the main script by ~250 lines (2,969 → 2,715), and additionally converts the eight back-references these primitives had in `bin/_lib_render.py` and `bin/_lib_diff_kernel.py` from `cctally`-namespace shims into honest direct imports of the new kernel — with no change to any command's behavior, flags, output, or exit codes: every reporting/`diff`/`project`/`cache-report`/`forecast`/`blocks`/`percent-breakdown`/`five-hour-blocks` golden test is byte-identical and the full harness + pytest suite (1,329 checks) passes, a new `tests/test_lib_fmt_extraction_invariants.py` locks the extraction's import discipline, and the new module ships in the npm/brew/public packages (promoted to the mirror allowlist). Purely a maintainability / code-organization change; nothing to do on upgrade.
+
 ## [1.22.3] - 2026-06-01
 
 ### Changed

package/bin/_cctally_record.py

@@ -384,6 +384,7 @@ _logged_window_key_coerce_failure = False
 #   _cctally_core.HOOK_TICK_THROTTLE_PATH / _LOCK_PATH
 #   c._FIVE_HOUR_JITTER_FLOOR_SECONDS — _lib_five_hour.* re-export
 #   c._RESET_PCT_DROP_THRESHOLD       — bin/_cctally_weekrefs.py constant (re-exported on cctally ns)
+#   c._is_reset_drop                  — bin/_cctally_weekrefs.py helper (re-exported on cctally ns)
 #   c.HOOK_TICK_DEFAULT_THROTTLE_SECONDS
 
 
@@ -1639,7 +1640,7 @@ def cmd_record_usage(args: argparse.Namespace) -> int:
                     if (
                         prior_end_dt > now_utc
                         and prior_pct is not None
-                        and (float(prior_pct) - float(weekly_percent)) >= c._RESET_PCT_DROP_THRESHOLD
+                        and c._is_reset_drop(prior_pct, weekly_percent)
                     ):
                         # See _backfill_week_reset_events for why we floor
                         # the reset moment to the hour (natural display
@@ -1667,7 +1668,7 @@ def cmd_record_usage(args: argparse.Namespace) -> int:
                     if (
                         prior_end_dt > now_utc
                         and prior_pct is not None
-                        and (float(prior_pct) - float(weekly_percent)) >= c._RESET_PCT_DROP_THRESHOLD
+                        and c._is_reset_drop(prior_pct, weekly_percent)
                     ):
                         # Pre-check (Q5 belt-and-suspenders): suppress duplicate
                         # event rows for the same new_week_end_at across

package/bin/_cctally_weekrefs.py

@@ -278,7 +278,7 @@ def _backfill_week_reset_events(conn: sqlite3.Connection) -> None:
             if (
                 captured_dt < prior_end_dt
                 and prior_pct is not None and cur_pct is not None
-                and (float(prior_pct) - float(cur_pct)) >= _RESET_PCT_DROP_THRESHOLD
+                and _is_reset_drop(prior_pct, cur_pct)
             ):
                 # Floor to the hour so the display boundary lands on the
                 # natural hour mark (Anthropic's reset times are always
@@ -309,7 +309,7 @@ def _backfill_week_reset_events(conn: sqlite3.Connection) -> None:
             if (
                 captured_dt < prior_end_dt
                 and prior_pct is not None and cur_pct is not None
-                and (float(prior_pct) - float(cur_pct)) >= _RESET_PCT_DROP_THRESHOLD
+                and _is_reset_drop(prior_pct, cur_pct)
             ):
                 # Pre-check on ``new_week_end_at`` (mirrors the live
                 # detection path's pre-check). Necessary because the
@@ -379,6 +379,40 @@ _RESET_PCT_DROP_THRESHOLD = 25.0
 # §2.1 (Q1) for rationale.
 _FIVE_HOUR_RESET_PCT_DROP_THRESHOLD = 5.0
 
+# Reset-to-zero discriminator (2026-06-01 surprise-reset fix). Anthropic's
+# weekly reset zeroes the counter mid-window, but the 25pp magnitude gate
+# above silently masks it for any user below ~25% usage (e.g. the observed
+# 14→0). A reset-to-zero is unambiguous REGARDLESS of magnitude: a lagging
+# API replica reports a slightly-lower number, never a clean 0 against real
+# usage. So the detector ALSO fires when the post value collapses to ~0
+# (<= _RESET_ZERO_FLOOR_PCT) with a drop clearing a small min-drop floor.
+# The floor rejects 1%→0% stale-replica jitter, which would otherwise write
+# a spurious week_reset_events row and segment the week.
+_RESET_ZERO_FLOOR_PCT = 1.0
+_RESET_ZERO_MIN_DROP_PCT = 3.0
+
+
+def _is_reset_drop(prior_pct: float, cur_pct: float) -> bool:
+    """True when ``prior_pct → cur_pct`` is a genuine weekly reset/credit.
+
+    Two independent percent-shape signals (OR):
+
+    * **Partial credit** — drop ``>= _RESET_PCT_DROP_THRESHOLD`` (25pp).
+    * **Reset-to-zero** — ``cur_pct`` collapses to ~0
+      (``<= _RESET_ZERO_FLOOR_PCT``) with a drop clearing
+      ``_RESET_ZERO_MIN_DROP_PCT``.
+
+    Callers retain the boundary predicates (same/advanced ``week_end_at``
+    AND ``prior_end_dt > now``); this helper owns ONLY the percent-shape
+    discrimination so all four 7d detection sites (live advance, live
+    in-place, backfill advance, backfill in-place) stay byte-identical.
+    """
+    cur = float(cur_pct)
+    drop = float(prior_pct) - cur
+    if drop >= _RESET_PCT_DROP_THRESHOLD:
+        return True
+    return cur <= _RESET_ZERO_FLOOR_PCT and drop >= _RESET_ZERO_MIN_DROP_PCT
+
 
 def _week_ref_has_reset_event(
     conn: sqlite3.Connection, ref: WeekRef

package/bin/_lib_diff_kernel.py

@@ -115,6 +115,11 @@ _lib_display_tz = _load_lib("_lib_display_tz")
 _resolve_tz = _lib_display_tz._resolve_tz
 format_display_dt = _lib_display_tz.format_display_dt
 
+# fmt/color/table primitives honest-imported from _lib_fmt (#126 C11)
+_lib_fmt = _load_lib("_lib_fmt")
+_style_ansi = _lib_fmt._style_ansi
+_supports_unicode_stdout = _lib_fmt._supports_unicode_stdout
+
 
 # === Honest imports from extracted homes ===================================
 # Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3: kernel symbols
@@ -147,14 +152,6 @@ def _iso_z(*args, **kwargs):
     return sys.modules["cctally"]._iso_z(*args, **kwargs)
 
 
-def _supports_unicode_stdout(*args, **kwargs):
-    return sys.modules["cctally"]._supports_unicode_stdout(*args, **kwargs)
-
-
-def _style_ansi(*args, **kwargs):
-    return sys.modules["cctally"]._style_ansi(*args, **kwargs)
-
-
 # Private eprint shim per spec §5.3 (pure layer does not back-import
 # cctally for ubiquitous helpers; eprint isn't actually called by the
 # moved code, but kept here as the canonical pure-layer pattern so

package/bin/_lib_fmt.py

@@ -0,0 +1,325 @@
+"""Shared fmt / color / table render primitives (pure-fn kernel).
+
+Holds the low-level formatting primitives extracted from bin/cctally
+(#126, C11): timestamp/week-window compaction, color/unicode capability
+detection, ANSI styling, display-width-aware boxed tables, number
+formatting + width-budget truncation. Pure: the only environment reads
+(os.environ, sys.stdout.isatty(), sys.stdout.encoding) happen INSIDE the
+functions at call time, never at import.
+
+Imported honestly by _lib_render.py and _lib_diff_kernel.py (via their
+_load_lib helpers); re-exported on the bin/cctally namespace for the
+_cctally_* command siblings and _lib_view_models.py (c.X accessor) and the
+test monkeypatch surfaces.
+
+Spec: docs/superpowers/specs/2026-06-01-extract-fmt-color-table-primitives-design.md
+"""
+from __future__ import annotations
+
+import datetime as dt
+import os
+import pathlib
+import re
+import sys
+import unicodedata
+from typing import Any
+
+# parse_iso_datetime: bare import matches the established _lib_* convention
+# (_lib_aggregators.py:86, _lib_diff_kernel.py:123 do the same).
+from _cctally_core import parse_iso_datetime
+
+
+# format_display_dt: loaded via the file-path _load_lib helper, NOT a bare
+# `from _lib_display_tz import …`. The repo's sibling loading deliberately
+# bypasses sys.path (test/loader contexts may lack bin/ on the path); every
+# _lib_* consumer of _lib_display_tz uses _load_lib (_lib_render.py:100,
+# _lib_diff_kernel.py:114, _lib_aggregators.py:75). _lib_fmt matches them.
+def _load_lib(name: str):
+    cached = sys.modules.get(name)
+    if cached is not None:
+        return cached
+    import importlib.util as _ilu
+    p = pathlib.Path(__file__).resolve().parent / f"{name}.py"
+    spec = _ilu.spec_from_file_location(name, p)
+    mod = _ilu.module_from_spec(spec)
+    sys.modules[name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_lib_display_tz = _load_lib("_lib_display_tz")
+format_display_dt = _lib_display_tz.format_display_dt
+
+
+def _parse_iso_datetime_optional(value: Any) -> dt.datetime | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    try:
+        return parse_iso_datetime(value, "timestamp")
+    except ValueError:
+        return None
+
+
+def _format_ts_compact(
+    value: str | None,
+    tz: "ZoneInfo | None" = None,
+) -> str:
+    """Compact ISO-instant -> "YYYY-MM-DD HH:MM" line.
+
+    F5 fix: optional ``tz`` localizes the parsed instant before strftime
+    AND appends the offset suffix via ``display_tz_label`` so the column
+    becomes unambiguous (mirrors ``format_display_dt``'s pattern). When
+    ``tz`` is None, returns the legacy UTC-clock string with no suffix
+    so existing callers keep their byte-stable output.
+    """
+    parsed = _parse_iso_datetime_optional(value)
+    if parsed is None:
+        return "n/a"
+    if tz is None:
+        # Host-local fallback / default-config path: preserve the original
+        # byte-stable host-naive strftime output (UTC-aware datetimes render
+        # UTC clock, no suffix). This branch is reachable in production for
+        # users whose ``display.tz`` resolves to None — NOT a legacy or
+        # back-compat path. The non-None branch routes through
+        # ``format_display_dt`` for tz-aware rendering.
+        return parsed.strftime("%Y-%m-%d %H:%M")
+    return format_display_dt(parsed, tz, fmt="%Y-%m-%d %H:%M", suffix=True)
+
+
+def _format_week_window(
+    week_start_date: str | None,
+    week_end_date: str | None,
+    week_start_at: str | None,
+    week_end_at: str | None,
+    tz: "ZoneInfo | None" = None,
+) -> str:
+    """Render a "<start> -> <end>" week-window column. F5 adds tz-aware
+    rendering for ISO-timestamp-bearing rows; legacy date-only rows pass
+    through unchanged. ``tz=None`` preserves byte-stable callers."""
+    if week_start_at and week_end_at:
+        return (
+            f"{_format_ts_compact(week_start_at, tz=tz)} -> "
+            f"{_format_ts_compact(week_end_at, tz=tz)}"
+        )
+    return f"{week_start_date or 'n/a'} -> {week_end_date or 'n/a'}"
+
+
+def _supports_color_stdout() -> bool:
+    # Matches ccusage's picocolors behavior exactly.
+    # FORCE_COLOR always enables (any value, including empty)
+    if "FORCE_COLOR" in os.environ:
+        return True
+    # NO_COLOR always disables (any value, including empty)
+    if "NO_COLOR" in os.environ:
+        return False
+    # CI environments get color
+    if "CI" in os.environ:
+        return True
+    # TTY check on stdout or stderr
+    if sys.stdout.isatty() or sys.stderr.isatty():
+        term = os.environ.get("TERM", "")
+        return term.lower() != "dumb"
+    return False
+
+
+def _style_ansi(text: str, code: str, enabled: bool) -> str:
+    if not enabled:
+        return text
+    return f"\033[{code}m{text}\033[0m"
+
+
+def _supports_unicode_stdout() -> bool:
+    encoding = (sys.stdout.encoding or "").upper()
+    return "UTF" in encoding
+
+
+def _display_width(s: str) -> int:
+    """Terminal cells consumed by ``s``.
+
+    Counts each codepoint by its East Asian Width: ``W`` / ``F`` (Wide
+    / Fullwidth) → 2 cells; combining marks → 0; everything else → 1.
+    Ambiguous (``A``) defaults to 1, matching every non-CJK terminal
+    locale — cctally has no CJK content in cell data, and `→` / `—` /
+    `·` (all `A`) are intentionally rendered narrow.
+
+    Used by `_boxed_table` so cells containing wide glyphs (notably
+    `⚡` U+26A1 on credit-row annotations) pad to the right cell count
+    rather than the right codepoint count. Without this, `len()`-based
+    padding under-pads by one cell per wide glyph and the right border
+    drifts off-column on those rows only.
+    """
+    width = 0
+    for ch in s:
+        if unicodedata.combining(ch):
+            continue
+        width += 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1
+    return width
+
+
+def _boxed_table(
+    headers: list[str],
+    rows: list[list[str]],
+    aligns: list[str] | None = None,
+    *,
+    color_header: bool = True,
+    compact: bool = False,
+) -> str:
+    if not headers:
+        return ""
+    col_count = len(headers)
+    aligns = aligns or ["left"] * col_count
+    if len(aligns) != col_count:
+        raise ValueError("aligns length must match headers length")
+
+    sanitized_rows: list[list[str]] = []
+    for row in rows:
+        normalized = [str(cell).replace("\n", " ") for cell in row]
+        if len(normalized) != col_count:
+            raise ValueError("row length must match headers length")
+        sanitized_rows.append(normalized)
+
+    widths: list[int] = []
+    for idx, header in enumerate(headers):
+        max_cell = max((_display_width(r[idx]) for r in sanitized_rows), default=0)
+        widths.append(max(_display_width(header), max_cell))
+
+    def _pad(text: str, width: int, align: str) -> str:
+        deficit = width - _display_width(text)
+        if deficit <= 0:
+            return text
+        pad = " " * deficit
+        if align == "right":
+            return pad + text
+        if align == "center":
+            left = deficit // 2
+            return (" " * left) + text + (" " * (deficit - left))
+        return text + pad
+
+    if _supports_unicode_stdout():
+        chars = {
+            "top_left": "┌",
+            "top_mid": "┬",
+            "top_right": "┐",
+            "mid_left": "├",
+            "mid_mid": "┼",
+            "mid_right": "┤",
+            "bottom_left": "└",
+            "bottom_mid": "┴",
+            "bottom_right": "┘",
+            "h": "─",
+            "v": "│",
+        }
+    else:
+        chars = {
+            "top_left": "+",
+            "top_mid": "+",
+            "top_right": "+",
+            "mid_left": "+",
+            "mid_mid": "+",
+            "mid_right": "+",
+            "bottom_left": "+",
+            "bottom_mid": "+",
+            "bottom_right": "+",
+            "h": "-",
+            "v": "|",
+        }
+
+    color_enabled = _supports_color_stdout()
+
+    def _dim(s: str) -> str:
+        return _style_ansi(s, "90", color_enabled)
+
+    # Issue #91 (Shape B): ``compact`` drops the 1-space cell padding to
+    # 0 on this content-sized table (which has no proportional-width path
+    # to force). Borders and rows both key off ``pad`` so the default
+    # (``pad == 1``) reproduces the prior output byte-for-byte.
+    pad = 0 if compact else 1
+    pad_s = " " * pad
+
+    def make_border(left: str, mid: str, right: str) -> str:
+        return _dim(
+            left
+            + mid.join(chars["h"] * (w + 2 * pad) for w in widths)
+            + right
+        )
+
+    def make_row(cells: list[str], *, header: bool = False) -> str:
+        is_total = not header and cells and cells[0].strip() == "Total"
+        styled_cells: list[str] = []
+        for i, raw in enumerate(cells):
+            text = _pad(raw, widths[i], aligns[i])
+            if header and color_header:
+                text = _style_ansi(text, "36", color_enabled)  # cyan text, like ccusage table head
+            elif is_total:
+                text = _style_ansi(text, "32", color_enabled)  # green text for totals
+            styled_cells.append(text)
+        v = _dim(chars["v"])
+        return (
+            v
+            + pad_s
+            + f"{pad_s}{v}{pad_s}".join(styled_cells)
+            + pad_s
+            + v
+        )
+
+    top = make_border(chars["top_left"], chars["top_mid"], chars["top_right"])
+    mid = make_border(chars["mid_left"], chars["mid_mid"], chars["mid_right"])
+    bottom = make_border(chars["bottom_left"], chars["bottom_mid"], chars["bottom_right"])
+
+    out_lines = [top, make_row(headers, header=True), mid]
+    for idx, row in enumerate(sanitized_rows):
+        out_lines.append(make_row(row, header=False))
+        if idx < len(sanitized_rows) - 1:
+            out_lines.append(mid)
+    out_lines.append(bottom)
+    return "\n".join(out_lines)
+
+
+def _fmt_num(n: int) -> str:
+    """Format integer with comma separators: 1234567 -> '1,234,567'."""
+    return f"{n:,}"
+
+
+def _truncate_num(formatted: str, width: int) -> str:
+    """Truncate a formatted number to fit width, replacing tail with '…'."""
+    if len(formatted) <= width:
+        return formatted
+    return formatted[: width - 1] + "\u2026"
+
+
+_ANSI_ESC_RE = re.compile(r"\033\[[0-9;]*m")
+
+
+def _truncate_display(text: str, width: int) -> str:
+    """Truncate to `width` visible chars, preserving ANSI escape sequences.
+
+    Unlike `_truncate_num`, which slices raw string indices, this walks
+    the text treating `\\033[...m` sequences as zero-width and counts
+    printable chars toward the width budget. Used for left-aligned
+    cells that may carry a styled anomaly-glyph prefix — slicing those
+    with `_truncate_num` can cut through an ANSI escape and bleed
+    color into adjacent cells.
+    """
+    # Fast path: no ANSI codes, fall back to raw-slice truncation.
+    if "\033" not in text:
+        return _truncate_num(text, width)
+    stripped_len = len(_ANSI_ESC_RE.sub("", text))
+    if stripped_len <= width:
+        return text
+    # Walk chars until we've emitted (width - 1) visible chars, copying
+    # ANSI sequences verbatim. Append reset + ellipsis to close any open
+    # style and preserve the fit-to-width contract.
+    out: list[str] = []
+    visible = 0
+    i = 0
+    target = width - 1
+    while i < len(text) and visible < target:
+        m = _ANSI_ESC_RE.match(text, i)
+        if m:
+            out.append(m.group(0))
+            i = m.end()
+            continue
+        out.append(text[i])
+        visible += 1
+        i += 1
+    return "".join(out) + "\033[0m\u2026"

package/bin/_lib_render.py

@@ -100,36 +100,21 @@ _short_model_name = _lib_pricing._short_model_name
 _lib_display_tz = _load_lib("_lib_display_tz")
 _resolve_tz = _lib_display_tz._resolve_tz
 
+# fmt/color/table primitives honest-imported from _lib_fmt (#126 C11)
+_lib_fmt = _load_lib("_lib_fmt")
+_supports_color_stdout = _lib_fmt._supports_color_stdout
+_supports_unicode_stdout = _lib_fmt._supports_unicode_stdout
+_style_ansi = _lib_fmt._style_ansi
+_fmt_num = _lib_fmt._fmt_num
+_truncate_num = _lib_fmt._truncate_num
+_boxed_table = _lib_fmt._boxed_table
+
 
 # Module-level back-ref shims. 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`` / ``bin/_cctally_cache.py``.
-def _supports_color_stdout(*args, **kwargs):
-    return sys.modules["cctally"]._supports_color_stdout(*args, **kwargs)
-
-
-def _supports_unicode_stdout(*args, **kwargs):
-    return sys.modules["cctally"]._supports_unicode_stdout(*args, **kwargs)
-
-
-def _style_ansi(*args, **kwargs):
-    return sys.modules["cctally"]._style_ansi(*args, **kwargs)
-
-
-def _fmt_num(*args, **kwargs):
-    return sys.modules["cctally"]._fmt_num(*args, **kwargs)
-
-
-def _truncate_num(*args, **kwargs):
-    return sys.modules["cctally"]._truncate_num(*args, **kwargs)
-
-
-def _boxed_table(*args, **kwargs):
-    return sys.modules["cctally"]._boxed_table(*args, **kwargs)
-
-
 def _format_block_start(*args, **kwargs):
     return sys.modules["cctally"]._format_block_start(*args, **kwargs)
 

package/bin/cctally

@@ -66,7 +66,6 @@ import textwrap
 import threading
 import time
 import traceback
-import unicodedata
 import urllib.error
 import urllib.request
 from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
@@ -329,6 +328,22 @@ format_display_dt = _lib_display_tz.format_display_dt
 _argparse_tz = _lib_display_tz._argparse_tz
 
 
+# fmt/color/table primitives moved to _lib_fmt.py (#126 C11)
+_lib_fmt = _load_sibling("_lib_fmt")
+_parse_iso_datetime_optional = _lib_fmt._parse_iso_datetime_optional
+_format_ts_compact = _lib_fmt._format_ts_compact
+_format_week_window = _lib_fmt._format_week_window
+_supports_color_stdout = _lib_fmt._supports_color_stdout
+_style_ansi = _lib_fmt._style_ansi
+_supports_unicode_stdout = _lib_fmt._supports_unicode_stdout
+_display_width = _lib_fmt._display_width
+_boxed_table = _lib_fmt._boxed_table
+_fmt_num = _lib_fmt._fmt_num
+_truncate_num = _lib_fmt._truncate_num
+_ANSI_ESC_RE = _lib_fmt._ANSI_ESC_RE
+_truncate_display = _lib_fmt._truncate_display
+
+
 _cctally_parser = _load_sibling("_cctally_parser")
 build_parser = _cctally_parser.build_parser
 _nonneg_int = _cctally_parser._nonneg_int
@@ -1920,75 +1935,8 @@ ORIGINAL_ENTRYPOINT: "str | None" = None
 _UPDATE_WORKER: "UpdateWorker | None" = None
 
 
-def _parse_iso_datetime_optional(value: Any) -> dt.datetime | None:
-    if not isinstance(value, str) or not value.strip():
-        return None
-    try:
-        return parse_iso_datetime(value, "timestamp")
-    except ValueError:
-        return None
-
-
-def _format_ts_compact(
-    value: str | None,
-    tz: "ZoneInfo | None" = None,
-) -> str:
-    """Compact ISO-instant -> "YYYY-MM-DD HH:MM" line.
-
-    F5 fix: optional ``tz`` localizes the parsed instant before strftime
-    AND appends the offset suffix via ``display_tz_label`` so the column
-    becomes unambiguous (mirrors ``format_display_dt``'s pattern). When
-    ``tz`` is None, returns the legacy UTC-clock string with no suffix
-    so existing callers keep their byte-stable output.
-    """
-    parsed = _parse_iso_datetime_optional(value)
-    if parsed is None:
-        return "n/a"
-    if tz is None:
-        # Host-local fallback / default-config path: preserve the original
-        # byte-stable host-naive strftime output (UTC-aware datetimes render
-        # UTC clock, no suffix). This branch is reachable in production for
-        # users whose ``display.tz`` resolves to None — NOT a legacy or
-        # back-compat path. The non-None branch routes through
-        # ``format_display_dt`` for tz-aware rendering.
-        return parsed.strftime("%Y-%m-%d %H:%M")
-    return format_display_dt(parsed, tz, fmt="%Y-%m-%d %H:%M", suffix=True)
-
-
-def _format_week_window(
-    week_start_date: str | None,
-    week_end_date: str | None,
-    week_start_at: str | None,
-    week_end_at: str | None,
-    tz: "ZoneInfo | None" = None,
-) -> str:
-    """Render a "<start> -> <end>" week-window column. F5 adds tz-aware
-    rendering for ISO-timestamp-bearing rows; legacy date-only rows pass
-    through unchanged. ``tz=None`` preserves byte-stable callers."""
-    if week_start_at and week_end_at:
-        return (
-            f"{_format_ts_compact(week_start_at, tz=tz)} -> "
-            f"{_format_ts_compact(week_end_at, tz=tz)}"
-        )
-    return f"{week_start_date or 'n/a'} -> {week_end_date or 'n/a'}"
-
-
-def _supports_color_stdout() -> bool:
-    # Matches ccusage's picocolors behavior exactly.
-    # FORCE_COLOR always enables (any value, including empty)
-    if "FORCE_COLOR" in os.environ:
-        return True
-    # NO_COLOR always disables (any value, including empty)
-    if "NO_COLOR" in os.environ:
-        return False
-    # CI environments get color
-    if "CI" in os.environ:
-        return True
-    # TTY check on stdout or stderr
-    if sys.stdout.isatty() or sys.stderr.isatty():
-        term = os.environ.get("TERM", "")
-        return term.lower() != "dumb"
-    return False
+# fmt/color/table primitives + _parse_iso_datetime_optional now live in
+# _lib_fmt.py (re-exported above) — #126 C11.
 
 
 def _resolve_color_enabled(args: argparse.Namespace) -> bool:
@@ -2049,209 +1997,6 @@ def _resolve_color_enabled(args: argparse.Namespace) -> bool:
     return False
 
 
-def _style_ansi(text: str, code: str, enabled: bool) -> str:
-    if not enabled:
-        return text
-    return f"\033[{code}m{text}\033[0m"
-
-
-def _supports_unicode_stdout() -> bool:
-    encoding = (sys.stdout.encoding or "").upper()
-    return "UTF" in encoding
-
-
-def _display_width(s: str) -> int:
-    """Terminal cells consumed by ``s``.
-
-    Counts each codepoint by its East Asian Width: ``W`` / ``F`` (Wide
-    / Fullwidth) → 2 cells; combining marks → 0; everything else → 1.
-    Ambiguous (``A``) defaults to 1, matching every non-CJK terminal
-    locale — cctally has no CJK content in cell data, and `→` / `—` /
-    `·` (all `A`) are intentionally rendered narrow.
-
-    Used by `_boxed_table` so cells containing wide glyphs (notably
-    `⚡` U+26A1 on credit-row annotations) pad to the right cell count
-    rather than the right codepoint count. Without this, `len()`-based
-    padding under-pads by one cell per wide glyph and the right border
-    drifts off-column on those rows only.
-    """
-    width = 0
-    for ch in s:
-        if unicodedata.combining(ch):
-            continue
-        width += 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1
-    return width
-
-
-def _boxed_table(
-    headers: list[str],
-    rows: list[list[str]],
-    aligns: list[str] | None = None,
-    *,
-    color_header: bool = True,
-    compact: bool = False,
-) -> str:
-    if not headers:
-        return ""
-    col_count = len(headers)
-    aligns = aligns or ["left"] * col_count
-    if len(aligns) != col_count:
-        raise ValueError("aligns length must match headers length")
-
-    sanitized_rows: list[list[str]] = []
-    for row in rows:
-        normalized = [str(cell).replace("\n", " ") for cell in row]
-        if len(normalized) != col_count:
-            raise ValueError("row length must match headers length")
-        sanitized_rows.append(normalized)
-
-    widths: list[int] = []
-    for idx, header in enumerate(headers):
-        max_cell = max((_display_width(r[idx]) for r in sanitized_rows), default=0)
-        widths.append(max(_display_width(header), max_cell))
-
-    def _pad(text: str, width: int, align: str) -> str:
-        deficit = width - _display_width(text)
-        if deficit <= 0:
-            return text
-        pad = " " * deficit
-        if align == "right":
-            return pad + text
-        if align == "center":
-            left = deficit // 2
-            return (" " * left) + text + (" " * (deficit - left))
-        return text + pad
-
-    if _supports_unicode_stdout():
-        chars = {
-            "top_left": "┌",
-            "top_mid": "┬",
-            "top_right": "┐",
-            "mid_left": "├",
-            "mid_mid": "┼",
-            "mid_right": "┤",
-            "bottom_left": "└",
-            "bottom_mid": "┴",
-            "bottom_right": "┘",
-            "h": "─",
-            "v": "│",
-        }
-    else:
-        chars = {
-            "top_left": "+",
-            "top_mid": "+",
-            "top_right": "+",
-            "mid_left": "+",
-            "mid_mid": "+",
-            "mid_right": "+",
-            "bottom_left": "+",
-            "bottom_mid": "+",
-            "bottom_right": "+",
-            "h": "-",
-            "v": "|",
-        }
-
-    color_enabled = _supports_color_stdout()
-
-    def _dim(s: str) -> str:
-        return _style_ansi(s, "90", color_enabled)
-
-    # Issue #91 (Shape B): ``compact`` drops the 1-space cell padding to
-    # 0 on this content-sized table (which has no proportional-width path
-    # to force). Borders and rows both key off ``pad`` so the default
-    # (``pad == 1``) reproduces the prior output byte-for-byte.
-    pad = 0 if compact else 1
-    pad_s = " " * pad
-
-    def make_border(left: str, mid: str, right: str) -> str:
-        return _dim(
-            left
-            + mid.join(chars["h"] * (w + 2 * pad) for w in widths)
-            + right
-        )
-
-    def make_row(cells: list[str], *, header: bool = False) -> str:
-        is_total = not header and cells and cells[0].strip() == "Total"
-        styled_cells: list[str] = []
-        for i, raw in enumerate(cells):
-            text = _pad(raw, widths[i], aligns[i])
-            if header and color_header:
-                text = _style_ansi(text, "36", color_enabled)  # cyan text, like ccusage table head
-            elif is_total:
-                text = _style_ansi(text, "32", color_enabled)  # green text for totals
-            styled_cells.append(text)
-        v = _dim(chars["v"])
-        return (
-            v
-            + pad_s
-            + f"{pad_s}{v}{pad_s}".join(styled_cells)
-            + pad_s
-            + v
-        )
-
-    top = make_border(chars["top_left"], chars["top_mid"], chars["top_right"])
-    mid = make_border(chars["mid_left"], chars["mid_mid"], chars["mid_right"])
-    bottom = make_border(chars["bottom_left"], chars["bottom_mid"], chars["bottom_right"])
-
-    out_lines = [top, make_row(headers, header=True), mid]
-    for idx, row in enumerate(sanitized_rows):
-        out_lines.append(make_row(row, header=False))
-        if idx < len(sanitized_rows) - 1:
-            out_lines.append(mid)
-    out_lines.append(bottom)
-    return "\n".join(out_lines)
-
-
-def _fmt_num(n: int) -> str:
-    """Format integer with comma separators: 1234567 -> '1,234,567'."""
-    return f"{n:,}"
-
-
-def _truncate_num(formatted: str, width: int) -> str:
-    """Truncate a formatted number to fit width, replacing tail with '…'."""
-    if len(formatted) <= width:
-        return formatted
-    return formatted[: width - 1] + "\u2026"
-
-
-_ANSI_ESC_RE = re.compile(r"\033\[[0-9;]*m")
-
-
-def _truncate_display(text: str, width: int) -> str:
-    """Truncate to `width` visible chars, preserving ANSI escape sequences.
-
-    Unlike `_truncate_num`, which slices raw string indices, this walks
-    the text treating `\\033[...m` sequences as zero-width and counts
-    printable chars toward the width budget. Used for left-aligned
-    cells that may carry a styled anomaly-glyph prefix — slicing those
-    with `_truncate_num` can cut through an ANSI escape and bleed
-    color into adjacent cells.
-    """
-    # Fast path: no ANSI codes, fall back to raw-slice truncation.
-    if "\033" not in text:
-        return _truncate_num(text, width)
-    stripped_len = len(_ANSI_ESC_RE.sub("", text))
-    if stripped_len <= width:
-        return text
-    # Walk chars until we've emitted (width - 1) visible chars, copying
-    # ANSI sequences verbatim. Append reset + ellipsis to close any open
-    # style and preserve the fit-to-width contract.
-    out: list[str] = []
-    visible = 0
-    i = 0
-    target = width - 1
-    while i < len(text) and visible < target:
-        m = _ANSI_ESC_RE.match(text, i)
-        if m:
-            out.append(m.group(0))
-            i = m.end()
-            continue
-        out.append(text[i])
-        visible += 1
-        i += 1
-    return "".join(out) + "\033[0m\u2026"
-
-
 def _trend_row_recency_seconds(row: dict[str, Any]) -> float:
     for key in ("asOf", "costCapturedAt", "usageCapturedAt", "weekStartAt"):
         parsed = _parse_iso_datetime_optional(row.get(key))
@@ -2650,6 +2395,9 @@ _compute_cost_for_weekref           = _cctally_weekrefs._compute_cost_for_weekre
 _apply_overlap_clamp_to_weekrefs    = _cctally_weekrefs._apply_overlap_clamp_to_weekrefs
 _RESET_PCT_DROP_THRESHOLD           = _cctally_weekrefs._RESET_PCT_DROP_THRESHOLD
 _FIVE_HOUR_RESET_PCT_DROP_THRESHOLD = _cctally_weekrefs._FIVE_HOUR_RESET_PCT_DROP_THRESHOLD
+_RESET_ZERO_FLOOR_PCT               = _cctally_weekrefs._RESET_ZERO_FLOOR_PCT
+_RESET_ZERO_MIN_DROP_PCT            = _cctally_weekrefs._RESET_ZERO_MIN_DROP_PCT
+_is_reset_drop                      = _cctally_weekrefs._is_reset_drop
 
 
 # Eager re-export of bin/_cctally_percent_breakdown.py — the percent-breakdown

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cctally",
-  "version": "1.22.3",
+  "version": "1.22.4",
   "description": "Claude Code usage tracker and local dashboard for Pro/Max subscription limits - weekly cost-per-percent trend, quota forecasts, threshold alerts. ccusage-compatible.",
   "homepage": "https://github.com/omrikais/cctally",
   "repository": {
@@ -54,6 +54,7 @@
     "bin/_lib_display_tz.py",
     "bin/_lib_doctor.py",
     "bin/_lib_five_hour.py",
+    "bin/_lib_fmt.py",
     "bin/_lib_jsonl.py",
     "bin/_lib_pricing.py",
     "bin/_lib_pricing_check.py",