cctally 1.11.1 → 1.13.0

package/bin/_cctally_record.py

@@ -2350,7 +2350,7 @@ def cmd_hook_tick(args: argparse.Namespace) -> int:
             cache_conn = open_cache_db()
             try:
                 stats = sync_cache(cache_conn)
-                ingested = int(stats.rows_inserted)
+                ingested = int(stats.rows_changed)
             finally:
                 try:
                     cache_conn.close()

package/bin/_cctally_setup.py

@@ -1716,13 +1716,23 @@ def _setup_install(args: argparse.Namespace) -> int:
         cache_conn = c.open_cache_db()
         try:
             stats = c.sync_cache(cache_conn)
-            rows = int(stats.rows_inserted)
+            rows = int(stats.rows_changed)
         finally:
             try:
                 cache_conn.close()
             except Exception:
                 pass
         bootstrap_rows = rows
+        # `rows` counts both genuine INSERTs and ccusage-parity DO UPDATE
+        # replacements (see IngestStats.rows_changed). On first install
+        # this is always 0-vs-N pure inserts (cache is empty), so "N new
+        # entries" is exactly accurate. On a re-install / upgrade path
+        # with active sessions, `rows` also counts UPSERT replacements
+        # (streaming-vs-final tiebreaker swaps), so the count is more
+        # accurately "ingest activity" than "rows newly added" — but
+        # we keep "new entries" because (a) it's still a useful signal
+        # to the operator that the cache is alive, and (b) the dominant
+        # case (first install) reads literally.
         out.append(f"✓ Synced session cache ({rows} new entries)")
     except Exception as exc:
         out.append(f"⚠ sync_cache during bootstrap failed: {exc}")

package/bin/_lib_diff_kernel.py

@@ -1234,11 +1234,18 @@ def _diff_render_section_table(
     used_pct_mode_a: str,
     used_pct_mode_b: str,
     threshold: "NoiseThreshold | None" = None,
+    compact: bool = False,
 ) -> str:
     """Render one bordered table for a section. The Total row sums all rows
     (visible + hidden) — the caller passes the unfiltered aggregate map as
-    total_a/total_b so hidden rows still contribute (spec §4 invariant)."""
+    total_a/total_b so hidden rows still contribute (spec §4 invariant).
+
+    ``compact`` (issue #91, Shape B) drops the 1-space cell padding to 0 on
+    this content-sized table, which has no proportional-width path to force.
+    ``pad == 1`` (the default) reproduces the prior output byte-for-byte."""
     boxes = _diff_box_chars()
+    pad = 0 if compact else 1
+    pad_s = " " * pad
     out: list = [_diff_section_heading(section.name, width), ""]
 
     header_cells: list = ["Model" if section.name == "models"
@@ -1318,7 +1325,7 @@ def _diff_render_section_table(
         fill = fill or boxes["h"]
         parts = [left]
         for i, w in enumerate(col_w):
-            parts.append(fill * (w + 2))
+            parts.append(fill * (w + 2 * pad))
             parts.append(right if i == n_cols - 1 else mid)
         return "".join(parts)
 
@@ -1340,7 +1347,7 @@ def _diff_render_section_table(
                 # result. Spaces stay outside the ANSI escape so column rules
                 # align identically with or without color.
                 styled = _style_ansi(padded, code, enabled=bool(code))
-                parts.append(f" {styled} ")
+                parts.append(f"{pad_s}{styled}{pad_s}")
                 parts.append(boxes["v"])
             out_lines.append("".join(parts))
         return "\n".join(out_lines)
@@ -1376,11 +1383,13 @@ def _diff_render_full_output(
     width: int,
     raw_aggregates: dict,
     tz: "ZoneInfo | None" = None,
+    compact: bool = False,
 ) -> str:
     """Compose banner + window header + each section's table.
 
     ``tz`` is forwarded to ``_diff_render_window_header`` for the date
-    labels; ``tz=None`` means host-local.
+    labels; ``tz=None`` means host-local. ``compact`` (issue #91, Shape B)
+    is forwarded to each section table's pad-reduction branch.
     """
     parts: list = [
         _diff_render_banner(), "",
@@ -1395,6 +1404,7 @@ def _diff_render_full_output(
             used_pct_mode_a=result.used_pct_mode_a,
             used_pct_mode_b=result.used_pct_mode_b,
             threshold=result.threshold,
+            compact=compact,
         ))
     return "\n".join(parts)
 

package/bin/_lib_jsonl.py

@@ -39,6 +39,11 @@ class UsageEntry:
     model: str
     usage: dict[str, Any]
     cost_usd: float | None
+    source_path: str   # REQUIRED — absolute JSONL path; basename used in
+                       # --debug samples (issue #89). Always supply a
+                       # non-empty path-like string; "" is invalid per
+                       # spec R5 (no silent empty-string passthrough,
+                       # crashes loudly at construction instead).
 
 
 @dataclass
@@ -59,14 +64,64 @@ class CodexEntry:
     source_path: str
 
 
+def _entry_token_total(entry: "UsageEntry") -> int:
+    """Sum of the four billed token fields. Mirrors ccusage's
+    `usage_token_total` in rust/crates/ccusage/src/claude_loader.rs:516."""
+    u = entry.usage
+    return (
+        int(u.get("input_tokens", 0) or 0)
+        + int(u.get("output_tokens", 0) or 0)
+        + int(u.get("cache_creation_input_tokens", 0) or 0)
+        + int(u.get("cache_read_input_tokens", 0) or 0)
+    )
+
+
+def _should_replace(
+    candidate: "UsageEntry", existing: "UsageEntry"
+) -> bool:
+    """Port of ccusage's `should_replace_deduped_entry` in
+    rust/crates/ccusage/src/claude_loader.rs:531. Higher token total wins;
+    on equal totals, the row with `speed` set (non-null) wins (the post-stream
+    finalization row carries `speed`; streaming intermediates don't).
+
+    The `usage.get("speed") is not None` check matches the SQL UPDATE WHERE
+    clause's `json_extract(..., '$.speed') IS NOT NULL` in `sync_cache`'s
+    INSERT … ON CONFLICT … DO UPDATE, keeping the direct-parse fallback and
+    cache-ingest paths in lockstep on the rare-but-possible "explicit JSON
+    null" payload.
+    """
+    c_total = _entry_token_total(candidate)
+    e_total = _entry_token_total(existing)
+    if c_total != e_total:
+        return c_total > e_total
+    return (candidate.usage.get("speed") is not None
+            and existing.usage.get("speed") is None)
+
+
 def _parse_usage_entries(
     jsonl_path: pathlib.Path,
     range_start: dt.datetime,
     range_end: dt.datetime,
-    seen_hashes: set[str] | None = None,
+    *,
+    dedupe_map: "dict[str, UsageEntry]",
 ) -> list[UsageEntry]:
-    """Parse assistant entries from a JSONL file within the given time range."""
-    entries: list[UsageEntry] = []
+    """Parse one JSONL file's assistant entries within [range_start, range_end].
+
+    Dedup contract (matches ccusage's `push_deduped_entry`):
+    - Entries with non-null (msg_id, req_id) go into `dedupe_map`; if a key
+      already maps to an entry, replace iff `_should_replace(candidate, existing)`.
+    - Entries with null msg_id or null req_id (rare in modern Claude Code,
+      but possible on synthetic / legacy emissions) skip the dedup map and
+      land in a separate list — partial UNIQUE index on the cache mirrors
+      this behavior.
+    - `<synthetic>` model rows are dropped entirely (matches ccusage's
+      claude_loader.rs:454).
+
+    Caller is responsible for sorting the returned list by timestamp if
+    needed; `_collect_entries_direct` does this once across all files
+    after flattening `dedupe_map.values()`.
+    """
+    no_key_entries: list[UsageEntry] = []
     try:
         with open(jsonl_path, "r", encoding="utf-8", errors="replace") as fh:
             for line in fh:
@@ -96,6 +151,11 @@ def _parse_usage_entries(
                 model = msg.get("model") or obj.get("model")
                 if not isinstance(model, str) or not model.strip():
                     continue
+                model = model.strip()
+                if model == "<synthetic>":
+                    # Matches ccusage's claude_loader.rs:454 — synthetic
+                    # placeholder rows carry no billable usage.
+                    continue
 
                 try:
                     ts = dt.datetime.fromisoformat(
@@ -109,16 +169,8 @@ def _parse_usage_entries(
                 if ts < range_start or ts > range_end:
                     continue
 
-                # Deduplicate by message.id + requestId (same as ccusage)
                 msg_id = msg.get("id")
                 req_id = obj.get("requestId")
-                if msg_id is not None and req_id is not None:
-                    entry_hash = f"{msg_id}:{req_id}"
-                    if seen_hashes is not None:
-                        if entry_hash in seen_hashes:
-                            continue
-                        seen_hashes.add(entry_hash)
-
                 cost_usd_raw = obj.get("costUSD")
                 cost_usd = (
                     float(cost_usd_raw)
@@ -126,19 +178,30 @@ def _parse_usage_entries(
                     else None
                 )
 
-                entries.append(UsageEntry(
+                entry = UsageEntry(
                     timestamp=ts,
-                    model=model.strip(),
+                    model=model,
                     usage=usage,
                     cost_usd=cost_usd,
-                ))
+                    source_path=str(jsonl_path),
+                )
+
+                if msg_id is None or req_id is None:
+                    no_key_entries.append(entry)
+                    continue
+                key = f"{msg_id}:{req_id}"
+                existing = dedupe_map.get(key)
+                if existing is None or _should_replace(entry, existing):
+                    dedupe_map[key] = entry
     except OSError as exc:
         _eprint(f"[cost] could not read {jsonl_path}: {exc}")
 
-    return entries
+    # The function returns ONLY this file's no-key entries; the caller
+    # flattens `dedupe_map.values()` once at the end across all files.
+    return no_key_entries
 
 
-def _iter_jsonl_entries_with_offsets(fh):
+def _iter_jsonl_entries_with_offsets(fh, path_str: str):
     """Yield (byte_offset, UsageEntry, msg_id, req_id) for each assistant
     entry starting from fh's current position.
 
@@ -185,6 +248,13 @@ def _iter_jsonl_entries_with_offsets(fh):
         model = msg.get("model") or obj.get("model")
         if not isinstance(model, str) or not model.strip():
             continue
+        model = model.strip()
+        if model == "<synthetic>":
+            # Matches ccusage's claude_loader.rs:454. Filtered at the
+            # iterator level so the cache ingest path can't accidentally
+            # store these rows even if a downstream loop forgets to
+            # double-check (see `sync_cache` in _cctally_cache.py).
+            continue
 
         try:
             ts = dt.datetime.fromisoformat(ts_raw.strip().replace("Z", "+00:00"))
@@ -202,9 +272,10 @@ def _iter_jsonl_entries_with_offsets(fh):
             offset,
             UsageEntry(
                 timestamp=ts,
-                model=model.strip(),
+                model=model,
                 usage=usage,
                 cost_usd=cost_usd,
+                source_path=path_str,
             ),
             msg_id,
             req_id,

package/bin/_lib_render.py

@@ -134,6 +134,94 @@ def _format_block_start(*args, **kwargs):
     return sys.modules["cctally"]._format_block_start(*args, **kwargs)
 
 
+def _ellipsize(content: str, width: int, unicode_ok: bool) -> str:
+    """Truncate ``content`` to ``width`` cells, marking the cut with an
+    ellipsis. Returns ``content`` unchanged when it already fits.
+
+    Used for BOTH header and (text) data cells so a column scaled below
+    its header-label width stays aligned with the border row (issue #102
+    (a)) — the header render previously padded without truncating, so a
+    label wider than its scaled column overflowed the box."""
+    if len(content) <= width:
+        return content
+    ell = "…" if unicode_ok else "..."
+    return content[: max(0, width - len(ell))] + ell
+
+
+def _scale_down_col_widths(
+    nat_widths: list[int],
+    aligns: list[str],
+    data_widths: list[int],
+    available: int,
+    *,
+    grow_idx: int,
+    min_text: int = 4,
+) -> list[int]:
+    """Allocate the per-column widths for the ``--compact`` / auto-overflow
+    scale-down branch of the project + Claude-session renderers.
+
+    Policy (issue #102 — recommendation (a) + (b)):
+
+      * **Numeric (right-aligned) columns are protected.** Their hard floor
+        is the widest DATA value (``data_widths[i]``), so the full number
+        always shows; the row render must never ellipsis-truncate a
+        right-aligned cell. A silently-wrong figure (``12,345,…``) is worse
+        than honest overflow.
+      * **Text (left-aligned) columns absorb the squeeze** and may truncate
+        — including their header label, which the header render ellipsizes
+        the same way (so a column may drop below header width while staying
+        box-aligned).
+      * When the natural widths fit, they are used verbatim and the slack
+        goes to ``grow_idx``. When shrinking is required, widths scale
+        proportionally, clamped to ``[floor, natural]``; any residual after
+        reclaiming all text slack is accepted as honest overflow rather than
+        corrupting a number.
+
+    ``data_widths[i]`` is the widest cell EXCLUDING the header, so a numeric
+    column is sized to its number — its (possibly wider, truncatable) header
+    label does not inflate the protected floor.
+    """
+    num_cols = len(nat_widths)
+    floors = [
+        min(max(data_widths[i], 1), nat_widths[i]) if aligns[i] == "right"
+        else min(min_text, nat_widths[i])
+        for i in range(num_cols)
+    ]
+    total_nat = sum(nat_widths)
+    if total_nat <= available:
+        widths = list(nat_widths)
+        slack = available - total_nat
+        if slack > 0 and 0 <= grow_idx < num_cols:
+            widths[grow_idx] += slack
+        return widths
+
+    scale = available / total_nat if total_nat > 0 else 1.0
+    widths = [
+        min(nat_widths[i], max(int(nat_widths[i] * scale), floors[i]))
+        for i in range(num_cols)
+    ]
+    overflow = sum(widths) - available
+    if overflow > 0:
+        # Reclaim from text columns (most slack above floor first); numeric
+        # columns are immovable. Residual overflow is honest (issue #102 (b)).
+        text_idx = sorted(
+            (i for i in range(num_cols) if aligns[i] != "right"),
+            key=lambda i: widths[i] - floors[i],
+            reverse=True,
+        )
+        for i in text_idx:
+            if overflow <= 0:
+                break
+            take = min(widths[i] - floors[i], overflow)
+            widths[i] -= take
+            overflow -= take
+    else:
+        slack = available - sum(widths)
+        if slack > 0 and 0 <= grow_idx < num_cols:
+            widths[grow_idx] += slack
+    return widths
+
+
 # Optional dependency: zoneinfo.ZoneInfo is referenced only as a string
 # annotation in moved code; no runtime import needed.
 
@@ -143,6 +231,7 @@ def _render_blocks_table(
     *,
     now: dt.datetime | None = None,
     tz: "ZoneInfo | None" = None,
+    compact: bool = False,
 ) -> str:
     """Render blocks as a ccusage-style ANSI table with box-drawing borders.
 
@@ -158,6 +247,11 @@ def _render_blocks_table(
 
     ``tz`` is the resolved display zone (``None`` means host local).
     Block-start cells are rendered in this zone.
+
+    ``compact`` forces the scale-down code path regardless of the actual
+    terminal width (Session A ``--compact`` flag; spec §7.6.1). Mirrors
+    the same kwarg on ``_render_bucket_table``. Auto-detected
+    width-overflow continues to trigger the same path as before.
     """
     if not blocks:
         return "No session blocks found in the specified date range."
@@ -416,10 +510,12 @@ def _render_blocks_table(
 
     # Scale down only when table exceeds terminal width.
     # ccusage does NOT expand columns when the table fits — it uses the
-    # padded content widths as-is.
+    # padded content widths as-is. Session A (spec §7.6.1): the
+    # ``compact`` kwarg forces this branch regardless of terminal width
+    # (Review-A P2-B; mirrors ``_render_bucket_table`` semantics).
     table_overhead = 3 * num_cols + 1
     available_width = term_width - table_overhead
-    if sum(col_widths) + table_overhead > term_width:
+    if compact or (sum(col_widths) + table_overhead > term_width):
         scale_factor = available_width / sum(col_widths)
         col_widths = [
             max(
@@ -977,6 +1073,7 @@ def _render_bucket_table(
     title_suffix: str,
     compact_split_fn: Callable[[str], str],
     breakdown: bool = False,
+    compact: bool = False,
 ) -> str:
     """Render bucket aggregates as a ccusage-style ANSI table.
 
@@ -985,6 +1082,8 @@ def _render_bucket_table(
       title_suffix    — banner text suffix ("Daily" or "Monthly").
       compact_split_fn — function that splits a bucket string into
                          "YYYY\\n..." for compact-mode two-line display.
+      compact         — force compact layout regardless of terminal width
+                        (Session A `--compact` flag; spec §7.6.1).
 
     Mirrors ccusage's ResponsiveTable behavior: single-line headers and dates
     when content fits the terminal; falls back to two-line compact headers
@@ -1109,7 +1208,11 @@ def _render_bucket_table(
         term_width = int(os.environ.get("COLUMNS", "120"))
 
     border_overhead = 3 * num_cols + 1
-    compact_mode = sum(col_widths) + border_overhead > term_width
+    # Session A (spec §7.6.1): `compact=True` (set by `--compact` flag on
+    # daily/monthly/weekly/blocks/...) forces compact-mode regardless of
+    # the actual terminal width. Auto-detected width-overflow continues to
+    # trigger compact mode as before.
+    compact_mode = compact or (sum(col_widths) + border_overhead > term_width)
 
     if compact_mode:
         # Scale down proportionally with narrow minimums.
@@ -1272,6 +1375,7 @@ def _render_weekly_table(
     weeks: list["SubWeek"],
     compact_split_fn: Callable[[str], str],
     breakdown: bool = False,
+    compact: bool = False,
 ) -> str:
     """Render weekly bucket aggregates as a ccusage-style ANSI table.
 
@@ -1292,6 +1396,10 @@ def _render_weekly_table(
 
     `first_col_name` and `title_suffix` are hardcoded to "Week" and
     "Weekly" respectively.
+
+    `compact` forces compact layout regardless of terminal width
+    (Session A `--compact` flag; spec \u00a77.6.1). Mirrors the same kwarg
+    on `_render_bucket_table` (Review-A P3-1).
     """
     assert len(week_pct_overlay) == len(buckets), (
         f"week_pct_overlay length {len(week_pct_overlay)} does not match "
@@ -1443,7 +1551,11 @@ def _render_weekly_table(
         term_width = int(os.environ.get("COLUMNS", "120"))
 
     border_overhead = 3 * num_cols + 1
-    compact_mode = sum(col_widths) + border_overhead > term_width
+    # Session A (spec §7.6.1): `compact=True` (set by `--compact` flag on
+    # daily/monthly/weekly/blocks/...) forces compact-mode regardless of
+    # the actual terminal width. Auto-detected width-overflow continues to
+    # trigger compact mode as before.
+    compact_mode = compact or (sum(col_widths) + border_overhead > term_width)
 
     if compact_mode:
         # Scale down proportionally with narrow minimums.
@@ -2099,6 +2211,7 @@ def _render_claude_session_table(
     title: str = "Claude Token Usage Report - Sessions",
     breakdown: bool = False,
     tz: "ZoneInfo | None" = None,
+    compact: bool = False,
 ) -> str:
     """Render Claude session aggregates matching upstream ccusage session view (11 cols).
 
@@ -2109,14 +2222,16 @@ def _render_claude_session_table(
     Structural clone of `_render_codex_session_table` with:
       - ``Reasoning`` column replaced by ``Cache Create`` (sourced from
         ``cache_creation_tokens`` instead of ``reasoning_output_tokens``).
-      - ``tz_name`` / ``force_compact`` parameters dropped — Claude-side
-        commands don't expose ``--timezone`` / ``--compact`` today; dates
-        render in local TZ via ``astimezone()`` and compact mode is
-        triggered by terminal width alone.
       - ``Session`` cell shows first 8 chars of ``session_id`` (full UUID
         lives in --json).
 
     ``breakdown`` toggles per-model sub-rows beneath each session row.
+
+    ``compact`` forces the proportional scale-down code path regardless
+    of the actual terminal width (Session A ``--compact`` flag; spec
+    §7.6.1; Review-A P2-B). Mirrors ``_render_codex_session_table``'s
+    ``force_compact`` semantics. Auto-detected width overflow continues
+    to trigger the same path.
     """
     color = _supports_color_stdout()
     unicode_ok = _supports_unicode_stdout()
@@ -2250,6 +2365,34 @@ def _render_claude_session_table(
 
     col_widths = [_wide_width(i, content_widths[i]) for i in range(num_cols)]
 
+    try:
+        term_width = os.get_terminal_size().columns
+    except (OSError, ValueError):
+        term_width = int(os.environ.get("COLUMNS", "120"))
+
+    border_overhead = 3 * num_cols + 1
+    # Session A (spec \u00a77.6.1; Review-A P2-B): the scale-down branch
+    # fires ONLY under explicit ``compact=True``. Pre-Session-A
+    # ``_render_claude_session_table`` had no auto-overflow branch
+    # (wide-by-default was the existing contract; 6 golden fixtures
+    # in tests/fixtures/session/ encode that contract). The
+    # Cross-Branch Reviewer flagged the gratuitous auto-detect arm
+    # added in fdfee047; this restores the pre-Session-A behavior
+    # while preserving the explicit-compact override.
+    if compact:
+        available = term_width - border_overhead
+        # Per-column widest DATA value (excludes the header row), so numeric
+        # columns are protected at their number width while header labels may
+        # truncate (issue #102). data_cells/footer carry the values; the
+        # header is added separately below.
+        data_widths = [0] * num_cols
+        for cells, _rt in raw_rows:
+            for i, (text, _c) in enumerate(cells):
+                data_widths[i] = max(data_widths[i], _max_line_width(text))
+        col_widths = _scale_down_col_widths(
+            col_widths, aligns, data_widths, available, grow_idx=1,
+        )
+
     def _split_cell(text: str) -> list[str]:
         return text.split("\n") if text else [""]
 
@@ -2290,13 +2433,15 @@ def _render_claude_session_table(
 
     out.append(_border_row(TL, T_DOWN, TR))
 
-    # Header
+    # Header — labels ellipsize like data cells so a column scaled below
+    # its header width stays box-aligned (issue #102 (a)).
     header_cells = [_split_cell(h) for h in headers]
     max_h = max(len(c) for c in header_cells)
     for li in range(max_h):
         parts = [_dim(V)]
         for i, cell in enumerate(header_cells):
             content = cell[li] if li < len(cell) else ""
+            content = _ellipsize(content, col_widths[i], unicode_ok)
             parts.append(f" {_cyan(_pad_cell(content, col_widths[i], aligns[i]))} ")
             parts.append(_dim(V))
         out.append("".join(parts))
@@ -2312,7 +2457,15 @@ def _render_claude_session_table(
             parts = [_dim(V)]
             for i, (text, cfn) in enumerate(cells):
                 content = split_cells[i][li] if li < len(split_cells[i]) else ""
-                padded = _pad_cell(content, col_widths[i], aligns[i])
+                # Ellipsis-truncate only TEXT cells under --compact. Numeric
+                # (right-aligned) cells are NEVER truncated — a wrong number
+                # is worse than honest overflow (issue #102 (b)); the column
+                # is floored at its full number width so this normally never
+                # overflows. Mirrors _render_codex_session_table.
+                w = col_widths[i]
+                if aligns[i] != "right":
+                    content = _ellipsize(content, w, unicode_ok)
+                padded = _pad_cell(content, w, aligns[i])
                 if cfn is not None:
                     padded = cfn(padded)
                 parts.append(f" {padded} ")
@@ -2368,6 +2521,8 @@ def _render_project_table(
     weeks_missing_snapshot: int = 0,
     weeks_in_range: int = 1,
     no_color: bool = False,
+    color: "bool | None" = None,
+    compact: bool = False,
 ) -> str:
     """Render project rollup as a ccusage-style ANSI table.
 
@@ -2381,7 +2536,12 @@ def _render_project_table(
     first for width calc, ANSI applied at render time) and same banner /
     border / separator glyphs.
     """
-    color = False if no_color else _supports_color_stdout()
+    # Session A (spec §7.3): caller may pass an explicit ``color`` bool
+    # to override the auto-detect (so the new bool ``--color`` flag can
+    # force ANSI under NO_COLOR=1 env). Legacy ``no_color`` kwarg path
+    # is preserved for callers that haven't migrated.
+    if color is None:
+        color = False if no_color else _supports_color_stdout()
     unicode_ok = _supports_unicode_stdout()
 
     def _dim(s: str) -> str:  return _style_ansi(s, "90", color)
@@ -2531,14 +2691,22 @@ def _render_project_table(
         term_width = int(os.environ.get("COLUMNS", "120"))
 
     border_overhead = 3 * num_cols + 1
-    if sum(col_widths) + border_overhead > term_width:
+    # Issue #91 (Shape A): the ``compact`` kwarg forces this scale-down
+    # branch regardless of terminal width, mirroring ``_render_blocks_table``
+    # / ``_render_bucket_table``. Auto-detected width-overflow continues to
+    # trigger the same path as before.
+    if compact or (sum(col_widths) + border_overhead > term_width):
         available = term_width - border_overhead
-        total_col = sum(col_widths)
-        scale = available / total_col if total_col > 0 else 1.0
-        col_widths = [max(int(w * scale), 8) for w in col_widths]
-        remainder = available - sum(col_widths)
-        if remainder > 0:
-            col_widths[0] += remainder  # grow Project column
+        # Per-column widest DATA value (excludes the header row): numeric
+        # columns are protected at their number width while header labels may
+        # truncate (issue #102 (a) + (b)).
+        data_widths = [0] * num_cols
+        for cells, _rt in raw_rows:
+            for i, (text, _c) in enumerate(cells):
+                data_widths[i] = max(data_widths[i], _max_line_width(text))
+        col_widths = _scale_down_col_widths(
+            col_widths, aligns, data_widths, available, grow_idx=0,
+        )
 
     def _split_cell(text: str) -> list[str]:
         return text.split("\n") if text else [""]
@@ -2585,6 +2753,7 @@ def _render_project_table(
         parts = [_dim(V)]
         for i, cell in enumerate(header_cells):
             content = cell[li] if li < len(cell) else ""
+            content = _ellipsize(content, col_widths[i], unicode_ok)
             parts.append(f" {_cyan(_pad_cell(content, col_widths[i], aligns[i]))} ")
             parts.append(_dim(V))
         out.append("".join(parts))
@@ -2599,10 +2768,12 @@ def _render_project_table(
             parts = [_dim(V)]
             for i, (text, cfn) in enumerate(cells):
                 content = split_cells[i][li] if li < len(split_cells[i]) else ""
+                # Numeric (right-aligned) cells are never ellipsized \u2014 a
+                # wrong number is worse than honest overflow (issue #102 (b));
+                # text cells truncate so the column can shrink (a).
                 w = col_widths[i]
-                if len(content) > w:
-                    ell = "\u2026" if unicode_ok else "..."
-                    content = content[: max(0, w - len(ell))] + ell
+                if aligns[i] != "right":
+                    content = _ellipsize(content, w, unicode_ok)
                 padded = _pad_cell(content, w, aligns[i])
                 if cfn is not None:
                     padded = cfn(padded)
@@ -2800,7 +2971,7 @@ def _render_five_hour_blocks_table(
                 "", "", "",
             ])
 
-    print(_boxed_table(headers, rows, aligns))
+    print(_boxed_table(headers, rows, aligns, compact=args.compact))
     glyph = " · ⚡ = block crossed weekly reset" if has_crossed else ""
     print(f"\n{len(block_dicts)} blocks · cost: ${total_cost:.2f}{glyph}")