cctally 1.77.0 → 1.79.0

package/bin/_lib_conversation_dispatch.py

@@ -787,13 +787,13 @@ def neutral_payload(
 
     Provider-specific selectors: Claude keeps its existing contract (``tool_use_id``
     + ``which ∈ {input, result}``), Codex uses ``block_key`` + ``which ∈ {call,
-    output}``. Statuses: ``ok`` | ``not_found`` (404) | ``gone`` (410 — the physical
+    output, event}``. Statuses: ``ok`` | ``not_found`` (404) | ``gone`` (410 — the physical
     record moved/mutated)."""
     cref = resolve_conversation_ref(ref)
     if cref is None:
         return {"status": "not_found", "conversation_key": ref}
     if cref.source == "codex":
-        if not block_key or which not in ("call", "output"):
+        if not block_key or which not in ("call", "output", "event"):
             return {"status": "not_found", "block_key": block_key, "which": which}
         return q.read_codex_payload(conn, cref.conversation_key, block_key, which)
     # Claude: tool_use_id + which={input,result}, contract unchanged.

package/bin/_lib_dashboard_json.py

@@ -0,0 +1,43 @@
+"""Strict outbound JSON contract shared by dashboard HTTP/SSE and Doctor.
+
+Python's ``json.dumps`` defaults to emitting JavaScript-only ``NaN`` and
+``Infinity`` tokens. Browsers reject those tokens in ``JSON.parse`` and
+``Response.json``. Normalize supported JSON containers recursively, then keep
+``allow_nan=False`` as the final fail-loud guard. Unsupported objects and
+non-finite mapping keys are deliberately not coerced.
+"""
+from __future__ import annotations
+
+import json
+import math
+from typing import Any
+
+
+def normalize_dashboard_json(value: Any) -> Any:
+    """Return a non-mutating JSON value with non-finite floats mapped to null."""
+    if isinstance(value, float):
+        return value if math.isfinite(value) else None
+    if isinstance(value, dict):
+        return {
+            key: normalize_dashboard_json(item)
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [normalize_dashboard_json(item) for item in value]
+    if isinstance(value, tuple):
+        return tuple(normalize_dashboard_json(item) for item in value)
+    return value
+
+
+def encode_dashboard_json(value: Any, **kwargs: Any) -> str:
+    """Serialize one outbound payload with browser-strict JSON semantics."""
+    return json.dumps(
+        normalize_dashboard_json(value),
+        allow_nan=False,
+        **kwargs,
+    )
+
+
+def encode_dashboard_json_bytes(value: Any, **kwargs: Any) -> bytes:
+    """UTF-8 bytes companion for HTTP response bodies."""
+    return encode_dashboard_json(value, **kwargs).encode("utf-8")

package/bin/_lib_doctor.py

@@ -234,6 +234,13 @@ class DoctorState:
     # retained corpus from unreadable metadata.
     codex_project_metadata_health: Optional[dict] = None
     codex_project_metadata_error: Optional[str] = None
+    # Beta-channel (spec 2026-07-21 §3): the configured RELEASE channel
+    # (stable|beta) that `cctally update` tracks — DISTINCT from the preview
+    # `channel` (prod|preview) above. Populated by doctor_gather_state from a
+    # raw config read (fail-soft to "stable"). Drives the `install.update_channel`
+    # check (WARN on beta+brew, else OK). Defaulted (placed last) so existing
+    # constructors stay valid and default to the stable posture.
+    update_channel: str = "stable"
 
 
 @dataclasses.dataclass(frozen=True)
@@ -445,6 +452,36 @@ def _check_install_dev_mode(s: DoctorState) -> CheckResult:
     )
 
 
+def _check_install_update_channel(s: DoctorState) -> CheckResult:
+    """Report the configured update (release) channel alongside the install
+    method (beta-channel, spec 2026-07-21 §3).
+
+    DISTINCT from the preview `channel` in install.mode: this reports the
+    `update.channel` config leaf (stable|beta) that `cctally update` tracks.
+    WARN on the brew+beta mismatch — Homebrew IS the stable channel (Q2), so
+    a beta opt-in on brew silently resolves stable; the WARN makes that
+    explicit and actionable. Otherwise always OK (a diagnostic surface, never
+    a hard failure — doctor exits 2 only on FAIL)."""
+    channel = s.update_channel or "stable"
+    if channel == "beta" and s.install_is_brew:
+        return CheckResult(
+            id="install.update_channel", title="Update channel",
+            severity="warn",
+            summary="beta (unavailable on Homebrew — installs track stable)",
+            remediation=(
+                "Homebrew tracks stable only. Install via npm or source to "
+                "receive beta releases, or run "
+                "`cctally config set update.channel stable`."
+            ),
+            details={"channel": channel, "method": "brew"},
+        )
+    return CheckResult(
+        id="install.update_channel", title="Update channel",
+        severity="ok", summary=channel, remediation=None,
+        details={"channel": channel},
+    )
+
+
 _REQUIRED_HOOK_EVENTS = ("PostToolBatch", "Stop", "SubagentStop")
 
 
@@ -1830,6 +1867,7 @@ def _check_db_conversations_reclaimable(s: DoctorState) -> CheckResult:
 _CATEGORY_DEFINITIONS: tuple[tuple[str, str, tuple[tuple[str, str], ...]], ...] = (
     ("install", "Install", (
         ("install.mode", "_check_install_dev_mode"),
+        ("install.update_channel", "_check_install_update_channel"),
         ("install.symlinks", "_check_install_symlinks"),
         ("install.path", "_check_install_path"),
         ("install.legacy_snippet", "_check_install_legacy_snippet"),

package/bin/_lib_milestone_history.py

@@ -0,0 +1,158 @@
+"""Pure kernel for the hero-modal milestone-history feature (stdlib only).
+
+Small, dependency-free helpers shared by the Claude + Codex history glue
+in ``_cctally_milestone_history.py``:
+
+* ``compute_detail_stamp`` — content digest used both on the SSE index
+  entry and the detail response so the client can cache by
+  ``(source, key, detail_stamp)`` and revalidate when a week's underlying
+  rows move (spec §2 caching/invalidation).
+* ``intersects`` — half-open interval intersection on epoch seconds
+  (a block appears in every week it intersects, spec §1b dual membership).
+* ``coalesce_week_refs`` — collapse same-``key`` ``WeekRef`` segments
+  produced by reset correction for an in-place-credited week into ONE
+  navigation entry spanning the outer cycle boundary (spec §1a); the
+  per-segment structure lives in the detail payload, never as duplicate
+  chips.
+
+No imports of the cctally namespace or ``_cctally_core`` — these are pure
+functions. ``coalesce_week_refs`` is generic over any frozen dataclass
+carrying ``key`` / ``week_start_at`` / ``week_end_at`` string fields
+(the ``WeekRef`` shape) via ``dataclasses.replace``.
+"""
+from __future__ import annotations
+
+import datetime as dt
+import hashlib
+from dataclasses import replace
+
+
+# Codex ``quota_window_blocks`` rows carry second-level capture jitter in their
+# ``resets_at``: one physical reset (weekly *or* 5h) surfaces as several rows
+# whose resets differ by a few seconds. This is the Codex-scoped analogue of
+# the Claude 5h jitter floor (``_FIVE_HOUR_JITTER_FLOOR_SECONDS``) — same
+# concept, different provider. Deliberately NOT ``_canonical_5h_window_key``,
+# which is Claude-scoped per spec §1c. 600s (10 min) sits far above the
+# observed jitter yet far below any genuine early re-anchor (hours apart) or a
+# real weekly reset (~7 days apart), so only jitter is collapsed.
+CODEX_CYCLE_JITTER_FLOOR_SECONDS = 600
+
+
+def cluster_by_reset_jitter(items, *, reset_key, floor_seconds=CODEX_CYCLE_JITTER_FLOOR_SECONDS):
+    """Group items that share one physical reset, collapsing capture jitter.
+
+    ``items`` is any iterable; ``reset_key(item)`` returns that item's reset as
+    an epoch ``int``/``float``. Items are sorted by reset ascending, and each
+    run of consecutive items whose neighbour-to-neighbour reset gap is
+    ``<= floor_seconds`` forms one cluster. A gap greater than the floor starts
+    a new cluster, so genuine early re-anchors (hours apart) and real weekly
+    resets (~7 days apart) stay in distinct clusters — only sub-floor jitter is
+    merged.
+
+    Returns a list of clusters (each a non-empty list of the original items),
+    ordered by ascending cluster reset; within a cluster items follow the reset
+    sort. An empty ``items`` yields ``[]``.
+    """
+    ordered = sorted(items, key=reset_key)
+    clusters: list = []
+    current: list = []
+    prev = None
+    for item in ordered:
+        r = reset_key(item)
+        if prev is None or (r - prev) <= floor_seconds:
+            current.append(item)
+        else:
+            clusters.append(current)
+            current = [item]
+        prev = r
+    if current:
+        clusters.append(current)
+    return clusters
+
+
+def compute_detail_stamp(*parts: object) -> str:
+    """Return a 16-hex-char sha256 digest over ``"|"``-joined ``str(p)``.
+
+    ``None`` parts serialize as the empty string so a nullable count/timestamp
+    contributes deterministically. Truncating to 16 chars keeps the wire small
+    while staying collision-safe for the small per-week input space.
+    """
+    joined = "|".join("" if p is None else str(p) for p in parts)
+    return hashlib.sha256(joined.encode("utf-8")).hexdigest()[:16]
+
+
+def intersects(start_a: int, end_a: int, start_b: int, end_b: int) -> bool:
+    """Half-open interval intersection on epoch seconds.
+
+    ``[start_a, end_a)`` overlaps ``[start_b, end_b)`` iff each interval
+    starts before the other ends. Used for block/week dual membership so a
+    block straddling a week boundary is reported in every week it intersects.
+    """
+    return start_a < end_b and start_b < end_a
+
+
+def _parse_epoch(value: "str | None") -> "int | None":
+    """Parse a canonical ISO-8601 timestamp to an epoch int, or ``None``.
+
+    Accepts a trailing ``Z`` or an explicit offset; a naive value is treated
+    as UTC. Returns ``None`` on empty / unparseable input so callers can skip
+    boundary-less refs.
+    """
+    if not value:
+        return None
+    try:
+        s = value.replace("Z", "+00:00")
+        parsed = dt.datetime.fromisoformat(s)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=dt.timezone.utc)
+    return int(parsed.timestamp())
+
+
+def coalesce_week_refs(refs: list) -> list:
+    """Collapse same-``key`` refs into one ref spanning the outer boundary.
+
+    Input is the ``get_recent_weeks`` ``WeekRef`` list (newest-first). An
+    in-place-credited week is represented there as TWO same-``key`` refs
+    (a pre-credit segment ``[orig_start, effective)`` and a post-credit
+    segment ``[effective, orig_end)``); every other week is a single ref.
+
+    The result preserves the newest-first order of each key's FIRST
+    occurrence, and for a multi-ref key emits one ref whose
+    ``week_start_at`` is the earliest segment start and ``week_end_at`` the
+    latest segment end (the outer cycle boundary). The original ISO strings
+    are carried through unchanged (no reformatting drift); comparison is on
+    parsed epochs so mixed ``Z``/offset forms order correctly.
+    """
+    order: list = []  # keys in first-occurrence order
+    groups: dict = {}  # key -> list of refs
+    for ref in refs:
+        k = ref.key
+        if k not in groups:
+            groups[k] = []
+            order.append(k)
+        groups[k].append(ref)
+
+    out: list = []
+    for k in order:
+        members = groups[k]
+        if len(members) == 1:
+            out.append(members[0])
+            continue
+        # Pick earliest start / latest end across the same-key segments.
+        earliest = members[0]
+        earliest_e = _parse_epoch(members[0].week_start_at)
+        latest_end_iso = members[0].week_end_at
+        latest_e = _parse_epoch(members[0].week_end_at)
+        for m in members[1:]:
+            se = _parse_epoch(m.week_start_at)
+            if se is not None and (earliest_e is None or se < earliest_e):
+                earliest, earliest_e = m, se
+            ee = _parse_epoch(m.week_end_at)
+            if ee is not None and (latest_e is None or ee > latest_e):
+                latest_e, latest_end_iso = ee, m.week_end_at
+        # Base on the earliest-start ref (its start_at/start date are the
+        # outer start), widen its end to the latest segment end.
+        out.append(replace(earliest, week_end_at=latest_end_iso))
+    return out

package/bin/_lib_source_analytics.py

@@ -83,9 +83,26 @@ def assign_collision_safe_project_labels(
     selection the exact string that terminal, JSON, and share emit.
     """
     values = tuple(entries)
+    assigned = collision_safe_project_label_map(
+        (entry.project_key, entry.project_label) for entry in values
+    )
+    return tuple(
+        replace(entry, display_label=assigned.get(entry.project_key, entry.project_label))
+        for entry in values
+    )
+
+
+def collision_safe_project_label_map(
+    identities_and_labels: Iterable[tuple[str, str]],
+) -> dict[str, str]:
+    """Allocate the shared deterministic privacy-safe label contract.
+
+    Callers supply opaque internal identities. Only the returned labels are
+    presentation data; the identity keys must remain inside the adapter.
+    """
     keys_by_label: dict[str, set[str]] = defaultdict(set)
-    for entry in values:
-        keys_by_label[entry.project_label].add(entry.project_key)
+    for identity, label in identities_and_labels:
+        keys_by_label[label].add(identity)
     # Never let an allocator-owned ``label (N)`` shadow a literal project
     # label.  Reserving every raw label also makes a later presentation pass
     # unnecessary, which avoids producing ``label (N) (N)``.
@@ -107,10 +124,7 @@ def assign_collision_safe_project_labels(
             assigned[key] = candidate
             used_labels.add(candidate)
             ordinal += 1
-    return tuple(
-        replace(entry, display_label=assigned.get(entry.project_key, entry.project_label))
-        for entry in values
-    )
+    return assigned
 
 
 def opaque_project_key(source: str, root_key: str, resolved_key: str) -> str:

package/bin/cctally

@@ -558,6 +558,10 @@ _lib_log = _load_sibling("_lib_log")
 _lib_json_envelope = _load_sibling("_lib_json_envelope")
 stamp_schema_version = _lib_json_envelope.stamp_schema_version
 
+# Strict outbound dashboard/Doctor JSON: recursive non-finite normalization
+# followed by allow_nan=False serialization.
+_lib_dashboard_json = _load_sibling("_lib_dashboard_json")
+
 _lib_changelog = _load_sibling("_lib_changelog")
 # Backward-compat re-export: callers and tests reach the helper through
 # ``cctally._release_read_latest_release_version`` (incl. monkeypatch
@@ -1127,6 +1131,10 @@ _UPDATE_CHECK_TTL_HOURS_MIN = _cctally_update._UPDATE_CHECK_TTL_HOURS_MIN
 _UPDATE_CHECK_TTL_HOURS_MAX = _cctally_update._UPDATE_CHECK_TTL_HOURS_MAX
 _normalize_update_check_enabled_value = _cctally_update._normalize_update_check_enabled_value
 _validate_update_check_ttl_hours_value = _cctally_update._validate_update_check_ttl_hours_value
+UPDATE_CHANNELS = _cctally_update.UPDATE_CHANNELS
+UPDATE_CHANNEL_DEFAULT = _cctally_update.UPDATE_CHANNEL_DEFAULT
+_validate_update_channel_value = _cctally_update._validate_update_channel_value
+resolve_update_channel = _cctally_update.resolve_update_channel
 _UPDATE_STATE_SCHEMA_MAX = _cctally_update._UPDATE_STATE_SCHEMA_MAX
 _UPDATE_SUPPRESS_SCHEMA_MAX = _cctally_update._UPDATE_SUPPRESS_SCHEMA_MAX
 _load_update_state = _cctally_update._load_update_state
@@ -1149,6 +1157,9 @@ _BREW_VERSION_RE_LIST = _cctally_update._BREW_VERSION_RE_LIST
 _update_user_agent = _cctally_update._update_user_agent
 _fetch_url = _cctally_update._fetch_url
 _check_npm_latest_version = _cctally_update._check_npm_latest_version
+_fetch_npm_dist_tag_version = _cctally_update._fetch_npm_dist_tag_version
+_resolve_npm_channel_target = _cctally_update._resolve_npm_channel_target
+_semver_or_parse_error = _cctally_update._semver_or_parse_error
 _check_brew_latest_version = _cctally_update._check_brew_latest_version
 _is_update_check_due = _cctally_update._is_update_check_due
 _do_update_check = _cctally_update._do_update_check
@@ -1158,6 +1169,9 @@ _spawn_background_telemetry_beat = _cctally_update._spawn_background_telemetry_b
 cmd_telemetry_beat_internal = _cctally_update.cmd_telemetry_beat_internal
 SKIP_USE_STATE_LATEST = _cctally_update.SKIP_USE_STATE_LATEST
 _format_update_command = _cctally_update._format_update_command
+BREW_BETA_ADVISORY = _cctally_update.BREW_BETA_ADVISORY
+_resolved_install_target = _cctally_update._resolved_install_target
+_resolved_update_command = _cctally_update._resolved_update_command
 _prerelease_note = _cctally_update._prerelease_note
 _format_update_check_json = _cctally_update._format_update_check_json
 _UPDATE_METHOD_HUMAN_LABEL = _cctally_update._UPDATE_METHOD_HUMAN_LABEL
@@ -1336,6 +1350,7 @@ _build_statusline_injections = _cctally_statusline._build_statusline_injections
 # `cctally._statusline_persist` (test surface) + the `_cctally()` accessor
 # resolve them.
 _statusline_persist = _cctally_statusline._statusline_persist
+_statusline_oauth_tick = _cctally_statusline._statusline_oauth_tick
 _fork_persist = _cctally_statusline._fork_persist
 _record_args = _cctally_statusline._record_args
 _try_acquire_persist_lock = _cctally_statusline._try_acquire_persist_lock
@@ -1626,6 +1641,14 @@ UPDATE_NPM_REGISTRY_URL = os.environ.get(
     "CCTALLY_TEST_UPDATE_NPM_URL",
     "https://registry.npmjs.org/cctally/latest",
 )
+# Beta dist-tag endpoint (beta-channel, spec 2026-07-21 §3). The client
+# resolves the beta target as SemVer-max(dist-tags.beta, dist-tags.latest);
+# an exact 404 here means the `beta` dist-tag is not yet published
+# (transition window → fall back to latest). Env-overridable for fixtures.
+UPDATE_NPM_BETA_REGISTRY_URL = os.environ.get(
+    "CCTALLY_TEST_UPDATE_NPM_BETA_URL",
+    "https://registry.npmjs.org/cctally/beta",
+)
 UPDATE_BREW_FORMULA_URL = os.environ.get(
     "CCTALLY_TEST_UPDATE_BREW_URL",
     "https://raw.githubusercontent.com/omrikais/homebrew-cctally/main/Formula/cctally.rb",
@@ -2931,6 +2954,18 @@ _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_milestone_history.py — the hero-modal
+# historical milestone navigation glue (week/cycle index + week/cycle detail).
+# Reached via `c.` from the envelope build, the source build, and the
+# /api/milestones route handler. Refs get their impure cctally symbols via the
+# module's own call-time _cctally() accessor, so load order is irrelevant.
+_cctally_milestone_history = _load_sibling("_cctally_milestone_history")
+build_claude_week_index  = _cctally_milestone_history.build_claude_week_index
+build_claude_week_detail = _cctally_milestone_history.build_claude_week_detail
+build_codex_cycle_index  = _cctally_milestone_history.build_codex_cycle_index
+build_codex_cycle_detail = _cctally_milestone_history.build_codex_cycle_detail
+
+
 # Eager re-export of bin/_cctally_percent_breakdown.py — the percent-breakdown
 # handler (C8, #125 Batch B). Parser dispatch reaches c.cmd_percent_breakdown.
 _cctally_percent_breakdown = _load_sibling("_cctally_percent_breakdown")
@@ -3075,6 +3110,7 @@ _tui_sparkline_big = _cctally_tui._tui_sparkline_big
 _tui_width_bucket = _cctally_tui._tui_width_bucket
 # Snapshot builders (per-panel + orchestrator + empty)
 _tui_build_percent_milestones = _cctally_tui._tui_build_percent_milestones
+_tui_build_five_hour_milestones = _cctally_tui._tui_build_five_hour_milestones  # milestone-history week detail c.
 _tui_build_current_week = _cctally_tui._tui_build_current_week
 _tui_build_forecast = _cctally_tui._tui_build_forecast
 _tui_build_trend = _cctally_tui._tui_build_trend