cctally 1.81.0 → 1.82.1

package/CHANGELOG.md

@@ -5,6 +5,26 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.82.1] - 2026-07-24
+
+### Changed
+- The public README is a fresh, shorter screenshot-led tour, and it now refreshes itself on every stable release: promoting a release regenerates the screenshots against that exact version and updates a "Latest stable" highlights block on the GitHub page automatically. (#354)
+
+### Fixed
+- The dashboard's Recent Sessions card shows session names again. Splitting transcript storage into its own database dropped the name lookup, so every row in the Session column had rendered a dash since then. Names come back from the stored conversation index, and a transcript store that is missing, locked, or rebuilding simply leaves the dash in place instead of holding up the rest of the dashboard. (#362)
+- The All tab's Recent Sessions rows now show Claude session names too, matching the Codex rows beside them; previously only Codex rows were named there. Names still appear only for a local viewer, exactly as on the Claude tab. (#363)
+- The Codex dashboard tab no longer blanks `SPENT THIS WEEK` (and `$/1% used`, `$/1% vs last week`, and the week label) after Codex has been idle for an hour. Codex only reports its quota while you are using it, so the weekly reading goes stale on an idle machine — the spend was never lost, just hidden. It now stays on screen, with the Snapshot chip naming the reading as stale and showing its age. (#350)
+- Forecasts still pause on stale Codex quota evidence, on the dashboard and in a shared report: `Forecast @ reset` and a shared forecast's `Projected` column show `—` rather than projecting from a reading that may be an hour old. (#350)
+- The All tab keeps withholding its combined total while a provider's quota evidence is stale, but now says that is the reason instead of reporting a generic degraded state. (#350)
+
+## [1.82.0] - 2026-07-24
+
+### Added
+- Embedded pricing for Claude Opus 5 (`claude-opus-5`) so Opus 5 sessions are costed correctly instead of contributing $0 as an unrecognized model. Anthropic ships it at the standard Opus rate — $5 / MTok input, $25 / MTok output, $6.25 / MTok 5-minute cache write, $0.50 / MTok cache read — with the full 1M-token context window at standard pricing (no long-context premium), verified against Anthropic's published pricing table; the pricing snapshot date moves to 2026-07-24. LiteLLM carries no Opus 5 entry yet, so the embedded table is simply ahead of it and `pricing-check` does not report drift.
+
+### Fixed
+- `cctally statusline`'s 🧠 context segment now measures a `claude-opus-5[1m]` session against its real 1,000,000-token window instead of silently falling back to the 200K family default, which inflated the reported context percentage roughly fivefold.
+
 ## [1.81.0] - 2026-07-24
 
 ### Added

package/README.md

@@ -6,7 +6,7 @@
 </p>
 
 <p align="center">
-  <strong>Local-first usage tracker for Claude Code on Pro/Max - live dashboard, conversation viewer, weekly cost-per-percent trend, quota forecast, and threshold alerts. ccusage-compatible.</strong>
+  <strong>See what Claude Code and Codex actually cost you: a local dashboard, conversation viewer, and CLI reports for your subscription quota.</strong>
 </p>
 
 <p align="center">
@@ -16,54 +16,58 @@
   <a href="https://github.com/omrikais/cctally/stargazers"><img src="https://img.shields.io/github/stars/omrikais/cctally.svg" alt="GitHub stars"></a>
 </p>
 
-Claude Code's Pro/Max plans meter you on a weekly quota, but the only signal you get is a percentage that creeps up until you cap. `cctally` turns that percentage into something you can act on: it reads your local session logs, computes cost in-process, and shows you **how much each percent of quota is actually costing you, whether you're on track to cap this week, and exactly where the spend is going** - across a live web dashboard, a read-only conversation viewer, and a full set of CLI reports. Everything runs locally against your own `~/.claude` data. No account, no API key, no cloud processing — cctally never uploads your session data, and its only telemetry is an anonymous, opt-out [install count](#privacy--telemetry).
+Your Claude Code plan meters you with a percentage that creeps up all week. cctally reads your local session logs and turns that percentage into dollars: what each percent of quota costs you, whether you are on track to cap before the reset, and where the spend is going. It does the same for OpenAI's Codex CLI. Everything runs on your own machine, against your own data. No account, no API key, and nothing is uploaded.
 
 <p align="center">
   <img src="docs/img/dashboard-desktop.png" alt="cctally dashboard, desktop view" width="900">
 </p>
 
+<!-- cctally:latest-stable:begin -->
+**Latest stable: v1.81.0** (2026-07-24)
+
+- cctally now tracks usage per account for each provider: if you use more than one Claude or Codex account on this machine, each account's percent, 5-hour, and quota milestones, and their alerts, are recorded and fire independently instead of silently colliding.
+- New `cctally account list|show|label` subcommand shows every observed account (provider, label, email, plan, first/last seen, and which is currently active) and lets you set a durable friendly label that survives a stats rebuild.
+- Optional per-account weekly budgets via `config set budget.accounts` (Claude) and `config set budget.codex.accounts` (Codex); a budget targets an immutable account even after you rename its label, and a Codex per-account budget works without a vendor-wide amount.
+<!-- cctally:latest-stable:end -->
+
 ## Quick start
 
-**Requirements:** Python 3.11+, macOS or Linux, Claude Code installed and run at least once.
+Requirements: Python 3.11+, macOS or Linux, Claude Code installed and run at least once.
 
 ```bash
 # Homebrew (macOS / Linux)
 brew install omrikais/cctally/cctally && cctally setup
 
-# …or npm
+# or npm
 npm install -g cctally && cctally setup
 
-# …or from source
+# or from source
 git clone https://github.com/omrikais/cctally && cd cctally && ./bin/cctally setup
 ```
 
-The reporting commands work right away — you don't need `cctally setup` first. Straight after an install, `npx cctally daily` (or, once it's global, `cctally daily`) reads your existing `~/.claude` session logs directly and prints a cost table; `cctally dashboard` and `cctally tui` work the same way. `cctally setup` is what adds *auto-recording* — the live status-line quota percentage and the hooks that keep data flowing as you work — so run it once you want continuous tracking rather than on-demand reports.
-
-`cctally setup` symlinks the binaries into `~/.local/bin/`, adds three additive hooks to `~/.claude/settings.json` (it never overwrites existing entries), and bootstraps the local SQLite cache — on a large session history that first-run sync now shows live progress instead of sitting silent. If `~/.local/bin/` isn't on your `PATH`, the script prints the line to add. The npm install needs Python 3 on `PATH` - if setup reports "python3 not found", install it (`brew install python` on macOS) and re-run.
+The reporting commands work immediately on your existing logs, before any setup. Running `cctally setup` once adds the hooks that record your quota percentage continuously as you work.
 
 ```bash
-cctally setup --status     # verify hooks + symlinks
-cctally daily              # cost-by-day - your first table
+cctally daily              # cost by day: your first table
 cctally dashboard          # opens http://127.0.0.1:8789
+cctally setup --status     # verify the install
 ```
 
-For status-line integration and tuning, see [docs/installation.md](docs/installation.md) and [docs/configuration.md](docs/configuration.md).
-
-**Beta channel (opt-in).** Every release ships to a beta channel first; the maintainer promotes the ones that prove out to stable, which is the default. To ride along with the newest builds as they land, opt in with `cctally config set update.channel beta` (npm or source installs — Homebrew tracks stable). `cctally update` then installs the exact latest beta version, and `cctally config set update.channel stable` flips you back cleanly with no silent downgrade. See [docs/commands/update.md](docs/commands/update.md#beta-channel).
+Install details (symlinks, PATH, Python version) live in [docs/installation.md](docs/installation.md). Every release ships to an opt-in beta channel first; see [docs/commands/update.md](docs/commands/update.md#beta-channel).
 
 ## The live dashboard
 
-`cctally dashboard` serves a web app at `localhost:8789` that updates live as you work - no refresh, no polling. Eleven panels cover the whole picture: **current week**, **forecast**, **$/1% trend**, **recent sessions**, **weekly**, **monthly**, **5-hour blocks**, **daily heatmap**, **projects**, **cache report**, and **recent alerts**. Any panel expands into a focused view, sessions are filterable and searchable, and a settings drawer tunes alerts and display options on the fly. It runs only on your own machine by default; one flag opens it to the other devices on your network when you want that.
+`cctally dashboard` serves a local web app that updates live as you work, with no refresh and no polling. Panels cover the current week, the forecast, the cost trend, sessions, 5-hour blocks, projects, and alerts. Any panel expands into a focused view, sessions are searchable, and every report can be exported as shareable Markdown, HTML, or SVG with project names anonymized by default. It stays on your machine unless you choose to open it to your network.
 
 <table>
   <tr>
     <td>
       <img src="docs/img/dashboard-modal.png" alt="Dashboard with trend modal open">
-      <br><em>Any panel expands into a focused view - here, twelve weeks of cost per percent.</em>
+      <br><em>Any panel expands into a focused view: here, twelve weeks of cost per percent.</em>
     </td>
     <td>
       <img src="docs/img/dashboard-warn.png" alt="Dashboard in warn state">
-      <br><em>When the forecast projects a cap before the weekly reset, the modal goes amber.</em>
+      <br><em>When the forecast projects a cap before the weekly reset, the modal turns amber.</em>
     </td>
   </tr>
   <tr>
@@ -76,16 +80,12 @@ For status-line integration and tuning, see [docs/installation.md](docs/installa
 
 See [docs/commands/dashboard.md](docs/commands/dashboard.md).
 
-## Conversation viewer ⭐
-
-The dashboard's **Conversations** tab is a read-only reader for your Claude Code transcripts - your local session history, rendered the way you'd actually want to review it. A searchable rail lists every conversation with its project, branch, model chips, and cost; the reader shows the full turn-by-turn flow with thinking blocks, tool calls (with diffs and command output), and a per-turn cost-and-token breakdown. Parallel **subagent threads** render as their own nested threads, an outline pane jumps you to any turn, and an in-conversation find bar plus a faceted full-text search (prompts, assistant text, tools, thinking) make a month of sessions navigable. The open conversation **live-tails** as you work, updating within a second.
+## Conversation viewer
 
-It only reads your transcripts - it never changes them - and everything stays on your own machine. Nothing is uploaded, and the viewer is reachable only from your computer unless you choose to share the dashboard with your network.
+The dashboard's Conversations tab is a read-only reader for your Claude Code transcripts. A searchable rail lists every conversation with its project, branch, models, and cost; the reader shows the full turn-by-turn flow with thinking blocks, tool calls, and per-turn cost. Subagent runs render as nested threads, and the open conversation live-tails as you work. It never modifies your transcripts, and it never leaves your machine.
 
 <p align="center">
   <img src="docs/img/conversation-reader.png" alt="Conversation viewer: rail, threaded reader, and outline" width="900">
-  <br>
-  <em>Rail, threaded reader with tool cards and a subagent thread, and the jump-to outline.</em>
 </p>
 
 <p align="center">
@@ -96,97 +96,68 @@ It only reads your transcripts - it never changes them - and everything stays on
 
 ## Cost per 1% of quota
 
-The signature view. `cctally report` reframes each subscription week's spend as **dollars per percent of quota used**, so you can see your spending efficiency trend week over week - and whether this week is pulling above or below the line - instead of staring at a raw percentage. Persisted to SQLite, so the comparison survives across runs.
+The signature view. `cctally report` reframes each week's spend as dollars per percent of quota used, so you can watch your spending efficiency trend week over week instead of staring at a raw percentage.
 
 <p align="center">
-  <img src="docs/img/cli-report.svg" alt="cctally report: $ per 1% weekly trend">
-  <br>
-  <em>Weekly cost as dollars per percent of quota, with the delta against the prior week.</em>
+  <img src="docs/img/cli-report.svg" alt="cctally report: dollars per 1% weekly trend">
 </p>
 
 See [docs/commands/report.md](docs/commands/report.md).
 
-## Forecast & budget
+## Forecast, budget, and alerts
 
-`cctally forecast` projects where your weekly percentage lands at the next reset - using both a week-average and a recent-24h rate - and tells you the daily $/% budget you'd need to stay under the 100% and 90% ceilings. When the data is thin it says so (`LOW CONF`) rather than guessing.
+`cctally forecast` projects where your weekly percentage lands at the next reset and tells you the daily budget that keeps you under the cap. `cctally budget` tracks a dollar target per provider over a calendar period. Native desktop notifications fire the moment you cross a percent, 5-hour, or budget threshold, so a runaway week cannot sneak up on you.
 
 <p align="center">
   <img src="docs/img/cli-forecast.svg" alt="cctally forecast: will I cap this week?">
-  <br>
-  <em>Projected percent at the weekly reset, plus the daily budget to stay under the cap.</em>
 </p>
 
-For dollar budgets, `cctally budget` tracks an equivalent-vs-actual spend target over a configurable calendar period - per vendor, for both Claude and Codex - with a pace projection and an `ok`/`warn`/`over` verdict. See [docs/commands/forecast.md](docs/commands/forecast.md) and [docs/commands/budget.md](docs/commands/budget.md).
-
-## Threshold alerts
+See [docs/commands/forecast.md](docs/commands/forecast.md), [docs/commands/budget.md](docs/commands/budget.md), and [docs/commands/alerts.md](docs/commands/alerts.md).
 
-Get a native desktop notification the moment you cross a percent milestone, so a runaway week can't sneak up on you. Alerts fire on weekly percent, 5-hour blocks, and budget thresholds, with three severity levels (info / warn / critical) and native popups on macOS and Linux - or run a command of your own. `cctally alerts test` confirms it's wired up. See [docs/commands/alerts.md](docs/commands/alerts.md).
+## 5-hour blocks
 
-## 5-hour analytics
-
-Claude Code's quota also runs on rolling 5-hour windows. `cctally blocks` and `cctally five-hour-blocks` break usage down per window - anchored to the real API resets where a recorded reset covers the window (`blocks` marks its heuristic fallback rows with `~`), not a re-sizable guess - with model and project rollups and cross-reset flags, and `cctally five-hour-breakdown` drills into the per-percent milestones inside a single block.
+Claude Code's quota also runs on rolling 5-hour windows. `cctally blocks` and `cctally five-hour-blocks` break usage down per window, anchored to the real API resets, with model and project rollups.
 
 <p align="center">
   <img src="docs/img/cli-five-hour-blocks.svg" alt="cctally five-hour-blocks: 5h analytics with model breakdown">
-  <br>
-  <em>Each 5-hour window, with rollup totals and 7-day drift.</em>
 </p>
 
 See [docs/commands/blocks.md](docs/commands/blocks.md) and [docs/commands/five-hour-blocks.md](docs/commands/five-hour-blocks.md).
 
-## Live terminal UI
+## Codex
 
-Prefer to stay in the terminal, or working over SSH? `cctally tui` shows the same live data as a refreshing terminal dashboard. It's the one feature that needs the optional `rich` library; every other command runs on a plain Python install with nothing else to set up.
+If you also use OpenAI's Codex CLI, cctally tracks it with the same depth. `cctally codex daily`, `monthly`, and `session` are drop-in replacements for the ccusage codex commands, reading from your local `~/.codex/sessions/`. `cctally codex weekly` adds a subscription week rollup, and `cctally codex quota` shows your native Codex rate limit windows.
 
 <p align="center">
-  <img src="docs/img/cli-tui.svg" alt="cctally tui: live terminal dashboard">
-  <br>
-  <em>The same data in the terminal, refreshed live.</em>
+  <img src="docs/img/cli-codex-daily.svg" alt="cctally codex daily: Codex cost by day">
 </p>
 
-See [docs/commands/tui.md](docs/commands/tui.md).
-
-## Shareable reports
-
-All eight reporting commands (`report`, `daily`, `monthly`, `weekly`, `forecast`, `project`, `five-hour-blocks`, `session`) can render to shareable Markdown, HTML, or SVG with `--format`, a light/dark `--theme`, and `--output` / `--copy` / `--open`. Project names anonymize by default (`--reveal-projects` opts in), so you can post a snapshot without leaking where you work. See [docs/commands/share.md](docs/commands/share.md).
-
-## Codex parity
-
-If you also use OpenAI's Codex CLI, `cctally codex daily / monthly / session` are drop-ins for `ccusage codex daily / monthly / session`, reading from `~/.codex/sessions/`. The flat `codex-*` forms (drop-ins for the standalone `ccusage-codex` binary) stay as aliases, and `cctally codex weekly` adds a subscription-week rollup that upstream doesn't have. See [docs/commands/codex.md](docs/commands/codex.md).
+See [docs/commands/codex.md](docs/commands/codex.md) and [docs/commands/codex-quota.md](docs/commands/codex-quota.md).
 
-## Diagnostics & upkeep
+## Terminal UI
 
-`cctally doctor` gives you a read-only health check - install, hooks, sign-in, database, data freshness, pricing, and safety - and the same status shows up in the dashboard. `cctally pricing-check` warns you when the built-in model pricing is getting stale, `cctally db` manages the local database, and `cctally update` keeps your install current. The local cache is always safe to delete or rebuild.
+Prefer to stay in the terminal, or working over SSH? `cctally tui` shows the same live data as a refreshing terminal dashboard. It is the one feature that needs the optional `rich` library; everything else runs on a plain Python install.
 
-## Privacy & telemetry
-
-cctally sends an anonymous, opt-out **install-count beat** — at most once a day — so the project can gauge how many people actually use it (npm and GitHub numbers are drowned in bots and mirrors). The entire payload is a one-way token that rotates every month (derived from a random local id that never leaves your machine and can't be recovered from the token), the cctally version, and a coarse OS family (`macos`/`linux`/`windows`/`other`). No identity, file paths, prompts, usage data, or stored IP — ever. The first beat is held for at least 24 hours after first run, so you always have a window to opt out first.
+<p align="center">
+  <img src="docs/img/cli-tui.svg" alt="cctally tui: live terminal dashboard">
+</p>
 
-Turn it off any time with `cctally telemetry off` (or `cctally config set telemetry.enabled false`, `CCTALLY_DISABLE_TELEMETRY=1`, or the community-standard `DO_NOT_TRACK=1`); it's also off automatically in dev checkouts. Run `cctally telemetry` to see the current state and exactly what would be sent. The full transparency page — token construction, retention, and an honest threat model — is [docs/telemetry.md](docs/telemetry.md).
+See [docs/commands/tui.md](docs/commands/tui.md).
 
-## A faster, local-first ccusage
+## ccusage compatibility
 
-`cctally` started as a local replacement for [`ccusage`](https://github.com/ryoppippi/ccusage) and stays compatible at the level of common flows: `cctally claude <cmd>` is a drop-in for `ccusage claude <cmd>` (and `cctally codex <cmd>` for `ccusage codex <cmd>`), with the flat forms (`cctally daily`, `cctally codex-daily`, …) kept as aliases. Paste your ccusage commands verbatim - then reach for the dashboard, forecast, trend, conversation viewer, and alerts that ccusage doesn't have.
+cctally started as a local replacement for [ccusage](https://github.com/ryoppippi/ccusage) and stays drop-in compatible: `cctally claude <cmd>` and `cctally codex <cmd>` accept your ccusage commands verbatim. It is also fast: first table on 30 days of session data took about 2.6 seconds against about 31 seconds for ccusage (about 12x, measured 2026-05-05; methodology in [bench/README.md](https://github.com/omrikais/cctally/blob/main/bench/README.md)).
 
-It's also fast. Pricing is built in and computed in-process from a local SQLite cache, with no external tools to spawn. First table on 30 days of session data: **~2.6s (cctally) vs ~31s (ccusage)**, about 12× faster. Measured by `bench/cctally-vs-ccusage.sh` on macOS arm64, 2026-05-05; your numbers will vary.[^bench]
+## Privacy
 
-<!--
-  Footnote target uses an absolute URL because GitHub's relative-link
-  rewriter doesn't traverse into GFM footnote `<li>` content; on the
-  repo home page (`/omrikais/cctally`, no trailing slash) the browser
-  would resolve `bench/README.md` against the page URL and produce
-  `/omrikais/bench/README.md` - a broken path. Regular paragraph links
-  are unaffected.
--->
-[^bench]: Methodology and reproduction: [`bench/README.md`](https://github.com/omrikais/cctally/blob/main/bench/README.md).
+Everything runs locally against your own `~/.claude` and `~/.codex` data; session content is never uploaded. The only telemetry is an anonymous, opt-out install-count beat (a rotating one-way token, the version, and a coarse OS family, at most once a day). Turn it off any time with `cctally telemetry off`. The full transparency page is [docs/telemetry.md](docs/telemetry.md).
 
 ## Documentation
 
 - [Installation](docs/installation.md): symlinks, status-line wiring, Python version.
-- [Configuration](docs/configuration.md): `config.json` shape and week-start rules.
+- [Configuration](docs/configuration.md): config.json shape and week-start rules.
 - [Architecture](docs/architecture.md): data flow, caches, week boundaries.
-- [Runtime data](docs/runtime-data.md): what lives in `~/.local/share/cctally/`.
-- [Telemetry](docs/telemetry.md): the anonymous install-count beat, in full — and how to opt out.
+- [Telemetry](docs/telemetry.md): the anonymous install-count beat, in full.
 - [Command reference](docs/commands/): one page per subcommand.
 
 ## License

package/bin/_cctally_cache.py

@@ -5569,6 +5569,57 @@ def open_conversations_db(*, attach_cache: bool = True) -> sqlite3.Connection:
     return conn
 
 
+def read_session_titles_bounded(
+    session_ids,
+    *,
+    timeout_s: float = 0.05,
+) -> dict:
+    """{session_id: title} for the dashboard Sessions panel — bounded, fail-soft.
+
+    The Sessions panel is an ACCOUNTING surface that shows one piece of
+    transcript-derived decoration (the session title). #320 made the transcript
+    corpus an independent store precisely so accounting can never wait on it, so
+    this read is deliberately not ``open_conversations_db``: that opener applies
+    the schema, runs the migration dispatcher, attaches ``cache.db``, and carries
+    the 15s store-policy ``busy_timeout`` — a locked or rebuilding store would
+    stall the whole sync tick before a fail-soft caller could give up.
+
+    Instead: one RAW ``mode=ro`` connection with a ``timeout_s`` busy timeout
+    (the same idiom the Codex sessions rows use for Codex's own
+    ``state_5.sqlite``), reading only the two INDEXED title sources via
+    ``session_titles_indexed_map`` — never the windowed ``conversation_messages``
+    scan. Every failure path — no store on disk, locked store, absent tables,
+    corruption — degrades to ``{}`` and the panel renders its em-dash fallback,
+    which self-heals on a later tick. Never creates the store.
+    """
+    ids = [sid for sid in dict.fromkeys(session_ids or ()) if sid]
+    if not ids:
+        return {}
+    path = _cctally_core.CONVERSATIONS_DB_PATH
+    try:
+        if not path.is_file():
+            return {}
+        uri = f"{path.resolve().as_uri()}?mode=ro"
+    except OSError:
+        return {}
+    conn: sqlite3.Connection | None = None
+    try:
+        conn = sqlite3.connect(uri, uri=True, timeout=max(timeout_s, 0.0))
+        return dict(
+            _load_lib("_lib_conversation_query").session_titles_indexed_map(
+                conn, ids,
+            )
+        )
+    except (sqlite3.Error, OSError):
+        return {}
+    finally:
+        if conn is not None:
+            try:
+                conn.close()
+            except sqlite3.Error:
+                pass
+
+
 def _import_legacy_conversation_rows(conn: sqlite3.Connection) -> None:
     """Bridge pre-028/compatibility rows into an empty conversation store.
 

package/bin/_cctally_dashboard_envelope.py

@@ -52,6 +52,9 @@ from _cctally_core import (
     _get_alerts_config,
     _get_budget_config,
 )
+from _lib_dashboard_sources import (
+    dashboard_resource_key as _dashboard_resource_key,
+)
 from _lib_display_tz import _compute_display_block, format_display_dt
 from _lib_pricing import _chip_for_model, _short_model_name
 
@@ -1647,9 +1650,76 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
         **sys.modules["_cctally_dashboard"]._channel_env_fragment(),
     }
     envelope.update(_source_bundle_to_envelope(getattr(snap, "source_bundle", None)))
+    _overlay_claude_source_session_titles(envelope, snap, transcripts_visible)
     return envelope
 
 
+def _claude_source_session_rows(envelope: dict) -> list:
+    """The SOURCE-scoped Claude session row lists, both of the places the All
+    tab may read them from (``sourceRows.ts::collectSourceSessionRows`` prefers
+    the nested provider payload and falls back to the sibling source entry)."""
+    sources = envelope.get("sources")
+    if not isinstance(sources, Mapping):
+        return []
+    out = []
+    candidates = [(sources.get("claude") or {}).get("data")]
+    all_data = (sources.get("all") or {}).get("data")
+    if isinstance(all_data, Mapping):
+        providers = all_data.get("providers")
+        if isinstance(providers, Mapping):
+            candidates.append(providers.get("claude"))
+    for data in candidates:
+        if not isinstance(data, Mapping):
+            continue
+        sessions = data.get("sessions")
+        if not isinstance(sessions, Mapping):
+            continue
+        rows = sessions.get("rows")
+        if isinstance(rows, list):
+            out.append(rows)
+    return out
+
+
+def _overlay_claude_source_session_titles(
+    envelope: dict, snap, transcripts_visible: bool,
+) -> None:
+    """Inject the gated session title into the source-scoped Claude rows (#363).
+
+    The Sessions card reads a DIFFERENT payload per tab: the legacy
+    ``sessions.rows`` block on the Claude tab, but the source-scoped rows on the
+    All tab. Those source rows are projected into the published source bundle on
+    the sync thread — one frozen bundle shared by every SSE client — so the
+    bundle deliberately carries NO transcript content: a build-time gate
+    decision cannot be right for every later connection, and the projection is
+    fed a fail-closed envelope precisely so nothing leaks into it.
+
+    The title therefore rides the SAME per-request gate as the legacy block, by
+    injection here rather than publication upstream: gate closed → the key stays
+    absent, exactly as before. Injection (rather than publish-then-strip) is what
+    makes it fail closed — a missed site omits a title, it never leaks one.
+
+    Safe to mutate: ``_source_wire_value`` rebuilds plain dicts/lists per call,
+    so these rows are this request's own copies.
+    """
+    if not transcripts_visible:
+        return
+    titles = {}
+    for session in getattr(snap, "sessions", ()) or ():
+        session_id = getattr(session, "session_id", None)
+        title = getattr(session, "title", None)
+        if isinstance(session_id, str) and session_id and title is not None:
+            titles[_dashboard_resource_key("session", "claude", session_id)] = title
+    if not titles:
+        return
+    for rows in _claude_source_session_rows(envelope):
+        for row in rows:
+            if not isinstance(row, dict):
+                continue
+            title = titles.get(row.get("key"))
+            if title is not None:
+                row["title"] = title
+
+
 def _session_detail_to_envelope(detail: "TuiSessionDetail") -> dict:
     """Serialize TuiSessionDetail for GET /api/session/:id (spec §3.2, §4.6.4).
 

package/bin/_cctally_dashboard_share.py

@@ -1504,7 +1504,16 @@ def _build_codex_source_share_snapshot(ls, *, state, panel: str,
                 continue
             forecast = row.get("forecast") if isinstance(row.get("forecast"), Mapping) else {}
             current = row.get("current_percent")
-            projected = forecast.get("projected_percent")
+            # #350 spec §3.6 — "Projections blank. Actuals stay." BOTH the build
+            # and the idle clock deliberately preserve `projected_percent`
+            # alongside a non-ok `status`, and this site formatted it with no
+            # status check at all. That was masked while a stale Codex source
+            # collapsed to `unavailable` here; §3.4 keeps the source coherent, so
+            # a shared forecast would otherwise publish a stale projection.
+            projected = (
+                forecast.get("projected_percent")
+                if forecast.get("status") == "ok" else None
+            )
             rows.append(ls.Row(cells={
                 "limit": ls.TextCell(str(row.get("label") or "Codex quota")),
                 "current": ls.TextCell("—" if current is None else f"{float(current):.1f}%"),