cctally 1.22.3 → 1.23.0

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_alert_axes.py

@@ -0,0 +1,44 @@
+"""Pure kernel: alert-axis descriptors + registry + shared severity policy.
+
+Single source of truth for axis *metadata* — id, chip/title labels (kept
+byte-identical with dashboard/web/src/lib/alertAxis.ts), the milestone-table
+name used by the dashboard envelope, and the axis-uniform severity policy
+(amber <95 / red >=95). This kernel does NOT own the write/transaction path:
+each axis keeps its own detect-and-arm code in bin/_cctally_record.py. The
+descriptor is the metadata/render contract, not the write engine.
+
+Stdlib-only, no I/O at import time. bin/cctally re-exports the public symbols.
+Spec: docs/superpowers/specs/2026-06-01-alerts-axis-registry-projected-pace-design.md
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# Severity boundary: thresholds at or above this render red, below it amber.
+# Mirrors the legacy hardcoded amber<95 / red>=95 split (axis-uniform v1).
+_SEVERITY_RED_FLOOR = 95
+
+
+def severity_for(threshold: int) -> str:
+    """Map a crossed integer threshold to a severity color ('amber' | 'red')."""
+    return "red" if int(threshold) >= _SEVERITY_RED_FLOOR else "amber"
+
+
+@dataclass(frozen=True)
+class AlertAxisDescriptor:
+    """Axis-agnostic metadata shared by the record path + dashboard envelope."""
+
+    id: str            # 'weekly' | 'five_hour' | 'budget' | 'projected'
+    chip_label: str    # SHOUT form, byte-identical with alertAxis.ts AXIS_CHIP_LABEL
+    title_label: str   # sentence-case form, byte-identical with AXIS_TITLE_LABEL
+    milestone_table: str  # SQLite table the dashboard envelope SELECTs from
+
+
+AXIS_REGISTRY: "tuple[AlertAxisDescriptor, ...]" = (
+    AlertAxisDescriptor("weekly", "WEEKLY", "Weekly", "percent_milestones"),
+    AlertAxisDescriptor("five_hour", "5H-BLOCK", "5h-block", "five_hour_milestones"),
+    AlertAxisDescriptor("budget", "BUDGET", "Budget", "budget_milestones"),
+    AlertAxisDescriptor("projected", "PROJECTED", "Projected", "projected_milestones"),
+)
+
+AXIS_BY_ID: "dict[str, AlertAxisDescriptor]" = {d.id: d for d in AXIS_REGISTRY}

package/bin/_lib_alerts_payload.py

@@ -242,3 +242,70 @@ def _build_alert_payload_budget(
             "consumption_pct": float(consumption_pct),
         },
     }
+
+
+def _alert_text_projected(payload: dict, tz: "ZoneInfo | None") -> tuple[str, str, str]:
+    """Build (title, subtitle, body) for a projected-pace alert (#121).
+
+    These fire on the WEEK-AVERAGE projection — what you're tracking toward at
+    the current week-average pace — NOT on an actual crossing. The text carries
+    an explicit "(projection)" / "on current pace" cue so a user never confuses
+    a projected alert with an actual-crossing one (which the weekly/budget
+    builders render). The rendered numbers come from the payload (the values
+    snapshotted at crossing), never from live config (Codex P0-4). ``tz`` is
+    accepted for signature parity with peer ``_alert_text_*`` builders and
+    intentionally unused (no instant is rendered, same as ``_alert_text_budget``).
+    """
+    metric = payload["metric"]
+    t = int(payload["threshold"])
+    proj = float(payload["projected_value"])
+    denom = float(payload["denominator"])
+    if metric == "weekly_pct":
+        title = f"cctally - projected to reach {t}% this week"
+        subtitle = "On current pace (projection)"
+        body = f"Projected ~{proj:.0f}% of cap by reset (week-average pace)"
+    else:  # budget_usd
+        title = "cctally - projected to exceed budget"
+        subtitle = f"On current pace (projection) - {t}% of budget"
+        body = (
+            f"Projected ${proj:,.2f} of ${denom:,.2f} budget "
+            f"(week-average pace)"
+        )
+    return title, subtitle, body
+
+
+def _build_alert_payload_projected(
+    *,
+    metric: str,
+    threshold: int,
+    projected_value: float,
+    denominator: float,
+    week_start_at: str,
+) -> dict:
+    """Build the alert payload for a projected-pace threshold crossing (#121).
+
+    ``axis: "projected"`` is the fourth alert axis; ``metric`` discriminates
+    ``weekly_pct`` (denominator 100.0, "% of cap") from ``budget_usd``
+    (denominator = target_usd, "$ of budget"). The frontend renders context
+    FROM these row-sourced fields (``metric`` / ``projected_value`` /
+    ``denominator``), not from live config that may have changed since crossing
+    (Codex P0-4). No ``crossed_at``/``alerted_at`` keys here: the projected
+    detector stamps ``alerted_at`` on the DB row itself in the same txn before
+    dispatch (set-then-dispatch), and the dashboard envelope reads it from the
+    row — mirroring ``_build_alert_payload_budget``'s context-only shape minus
+    the redundant timestamp echo.
+    """
+    return {
+        "id": f"projected:{week_start_at}:{metric}:{int(threshold)}",
+        "axis": "projected",
+        "metric": str(metric),
+        "threshold": int(threshold),
+        "projected_value": float(projected_value),
+        "denominator": float(denominator),
+        "context": {
+            "week_start_at": week_start_at,
+            "metric": str(metric),
+            "projected_value": float(projected_value),
+            "denominator": float(denominator),
+        },
+    }

package/bin/_lib_budget.py

@@ -52,6 +52,7 @@ class BudgetStatus:
     elapsed_fraction: float             # [0, 1]
     projected_eow_low_usd: float
     projected_eow_high_usd: float
+    week_avg_projection_usd: float      # spent + rate_avg*remaining (smooth estimator)
     verdict: str                        # "ok" | "warn" | "over"
     daily_budget_remaining_usd: float   # remaining / remaining-days
     daily_pace_usd: float               # current burn $/day (week-average)
@@ -93,6 +94,12 @@ def compute_budget_status(inputs: BudgetInputs) -> BudgetStatus:
         spent, remaining_hours, rate_low, rate_high
     )
 
+    # Smooth week-average end-of-week projection (additive surface field).
+    # Distinct from the displayed band (which keys off the high end): this is
+    # the conservative week-average value the projected-pace alert axis fires
+    # on. spent + rate_avg*remaining (== project_linear collapsed to one rate).
+    week_avg_projection_usd = spent + rate_avg * remaining_hours
+
     daily_pace_usd = rate_avg * 24.0
     daily_budget_remaining_usd = (
         (remaining_usd / remaining_days) if remaining_days > 0 else remaining_usd
@@ -125,6 +132,7 @@ def compute_budget_status(inputs: BudgetInputs) -> BudgetStatus:
         elapsed_fraction=elapsed_fraction,
         projected_eow_low_usd=projected_low,
         projected_eow_high_usd=projected_high,
+        week_avg_projection_usd=week_avg_projection_usd,
         verdict=verdict,
         daily_budget_remaining_usd=daily_budget_remaining_usd,
         daily_pace_usd=daily_pace_usd,

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)