ccdeck 3.39.4 → 3.40.0

package/dist/web/index.html

@@ -66,8 +66,8 @@
         document.documentElement.setAttribute("data-color-scheme", lightThemes.indexOf(theme) >= 0 ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-CxIdVCPz.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-TDFtmv7q.css">
+    <script type="module" crossorigin src="/assets/index-Di3xMUCd.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-8IDHjTIH.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccdeck",
-  "version": "3.39.4",
+  "version": "3.40.0",
   "description": "Local dashboard for Claude Code and Codex CLI sessions: which Claude Code session needs input, every tool call and Claude Code subagent live, token cost and quota, several Claude accounts. Run npx ccdeck.",
   "type": "module",
   "bin": {

package/release-notes.json

@@ -76,6 +76,24 @@
     "3.38.6",
     "3.39.4"
   ],
+  "3.40.0": [
+    {
+      "title": "📻 Explore radio around the world",
+      "body": "Open Radio from the right sidebar to discover stations on a world map, filter by country, sound or language, and save your favorites. Recent listening, a daily pick and Surprise me make it easier to find something to play. Music keeps playing when you close the explorer. Volume now adjusts in 1% steps, and an unavailable stream automatically advances to the next station after one second."
+    },
+    {
+      "title": "🦊 Choose your canvas companion",
+      "body": "Choose Deck companion, Fox or Penguin in Settings › Appearance. Your companion shares the existing canvas movements and music controls, and your choice stays saved."
+    },
+    {
+      "title": "📊 See what each session used",
+      "body": "Open a session’s usage details to inspect tokens, models and estimated cost. For Codex, compare Automatic, Standard, Fast and Flex pricing estimates without changing your Codex settings or billing."
+    },
+    {
+      "title": "A clearer canvas",
+      "body": "Session cards, tool traces and connections are easier to scan. The canvas reframes more reliably when resizing to portrait or rearranging sessions, and model cost estimates use updated pricing."
+    }
+  ],
   "3.39.3": [
     {
       "title": "A cleaner desktop window",

package/src/server/account-projects.mjs

@@ -33,7 +33,7 @@ import { readSwapLog, accountAtTime, trackedSince, seedActive, markGap } from ".
 // and a session's card cannot disagree about which lines billed anything, nor
 // about the speed they were billed at — see transcript-scan.mjs.
 import {
-  billedSpeed, hasSpend, MAX_SPEEDS_PER_MODEL, UNRECOGNISED_SPEED,
+  billedSpeed, isLongContextRequest, hasSpend, MAX_SPEEDS_PER_MODEL, UNRECOGNISED_SPEED,
   requestBilling, newRequestLedger, noteRequestRecord, streamingRequestId,
   BILL_LINE, REBILL_REQUEST, SKIP_LINE,
 } from "./transcript-scan.mjs";
@@ -43,7 +43,7 @@ import {
  *  a per-account total is never quietly inflated by work that is not that
  *  account's. A NUL keeps it from ever colliding with a real `email@@org` key. */
 export const UNATTRIBUTED = "\u0000unattributed";
-const STATE_VERSION = 6;
+const STATE_VERSION = 7;
 
 /** Where the tally and cursors live, beside cswap-auto's own state. */
 export function statePath(home = homedir()) {
@@ -102,6 +102,7 @@ function asUsageTotals(c) {
 function addInto(dst, src) {
   dst.i += src.i; dst.o += src.o; dst.cr += src.cr;
   dst.cc += src.cc; dst.c1h += src.c1h; dst.c5m += src.c5m;
+  if (src.l) addInto(dst.l ??= zero(), src.l);
   if (src.s) for (const [speed, share] of Object.entries(src.s)) addInto(speedShareOf(dst, speed), share);
   return dst;
 }
@@ -282,22 +283,29 @@ export function foldLine(tally, line, timeline, from) {
   const speed = billedSpeed(obj);
   const share = speed ? speedShareKey(counters, speed) : null;
   if (share) addInto(counters.s[share], c);
+  const long = isLongContextRequest(model, usage);
+  if (long) {
+    addInto(counters.l ??= zero(), c);
+    if (share) addInto(counters.s[share].l ??= zero(), c);
+  }
   if (billing === REBILL_REQUEST) dropIfEmpty(tally, ledger.streaming);
   if (billing === BILL_LINE || !requests) return;
   // What a request still streaming was charged, and where, so its final
   // record can take that back, in this pass or a later one.
   const id = streamingRequestId(obj);
-  requests[from.path].streaming = id === null ? null : { id, at: [key, cwd, day, model], s: share, c };
+  requests[from.path].streaming = id === null ? null : { id, at: [key, cwd, day, model], s: share, long, c };
 }
 
 /** Take a streaming request's charge back out of the row it was charged to,
  *  for its later record to charge in its place. A row pruned since has
  *  nothing left to take back. */
-function refund(tally, { at: [key, cwd, day, model], s, c }) {
+function refund(tally, { at: [key, cwd, day, model], s, long, c }) {
   const counters = tally[key]?.[cwd]?.[day]?.[model];
   if (!counters) return;
   takeFrom(counters, c);
   if (s && counters.s?.[s]) takeFrom(counters.s[s], c);
+  if (long && counters.l) takeFrom(counters.l, c);
+  if (long && s && counters.s?.[s]?.l) takeFrom(counters.s[s].l, c);
 }
 
 /** Remove what a refund left at zero — a speed share, or a whole row whose
@@ -500,14 +508,15 @@ export function createProjectRollup({
         state = disk;
         state.folders ??= {};
         state.requests ??= {};
-      } else if (disk && [1, 2, 3, 4, 5].includes(disk.version)) {
+      } else if (disk && [1, 2, 3, 4, 5, 6].includes(disk.version)) {
         // Version 1 counted every API content block; version 2 keyed each row
         // by the line's own cwd, a row per folder the agent cd'd into (#1278);
         // version 3 kept no speed, so every fast turn read at the standard
         // rate; version 4 billed a subagent's request from its streaming
         // snapshot, most of its output and its speed missing (#1883); version
         // 5 billed a resumed subagent's request again each time its file
-        // restated its history. None of them can be re-keyed, since it no
+        // restated its history; version 6 kept no per-request context tiers.
+        // None of them can be re-keyed, since it no
         // longer knows which transcript a count came from. Keep the heartbeat
         // so a restart gap remains fenced, but rebuild the tally from
         // transcripts.

package/src/server/ccusage-session.mjs

@@ -0,0 +1,60 @@
+// ccusage's two session formats, reduced to the figures the inspector needs.
+// No prompts, tool arguments or transcript text cross this boundary.
+const number = value => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+const counters = value => ({
+  inputTokens: number(value?.inputTokens), outputTokens: number(value?.outputTokens),
+  cacheReadTokens: number(value?.cacheReadTokens), cacheCreationTokens: number(value?.cacheCreationTokens),
+  reasoningOutputTokens: number(value?.reasoningOutputTokens),
+});
+const tokenTotal = row => row.inputTokens + row.outputTokens + row.cacheReadTokens + row.cacheCreationTokens;
+const date = value => typeof value === "string" && Number.isFinite(Date.parse(value)) ? value : null;
+
+export function validSessionLookup(agent, id, speed = "auto") {
+  if (agent !== "claude" && agent !== "codex") return false;
+  if (!["auto", "standard", "fast", "flex"].includes(speed) || (agent !== "codex" && speed !== "auto")) return false;
+  if (typeof id !== "string" || id.includes("..")) return false;
+  return agent === "codex"
+    ? /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i.test(id)
+    : /^[a-z\d][a-z\d._:-]{0,255}$/i.test(id);
+}
+
+export function sessionDetail(raw, agent, sessionId, speed = "auto") {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  if (typeof raw.sessionId !== "string" || !Number.isFinite(raw.totalTokens)
+      || !Number.isFinite(raw.totalCost) || raw.totalTokens < 0 || raw.totalCost < 0) return null;
+  // Codex answers with its rollout ID (path + UUID); Claude answers with the
+  // requested filename. Never display another session as the one requested.
+  const uuid = raw.sessionId.match(/[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}(?:\.jsonl(?:\.zst)?)?$/i)?.[0]
+    .replace(/\.jsonl(?:\.zst)?$/i, "");
+  if (agent === "codex" ? uuid?.toLowerCase() !== sessionId.toLowerCase() : raw.sessionId !== sessionId) return null;
+  const models = new Map();
+  let usage = counters(raw), firstActivity = date(raw.firstActivity), lastActivity = date(raw.lastActivity);
+  let entries = null;
+  if (agent === "claude" && Array.isArray(raw.entries)) {
+    usage = counters({});
+    entries = raw.entries.length;
+    for (const entry of raw.entries) {
+      const row = counters(entry);
+      for (const key of Object.keys(usage)) usage[key] += row[key];
+      const model = typeof entry?.model === "string" ? entry.model : "unknown";
+      const bucket = models.get(model) ?? { model, ...counters({}), missingPricing: false };
+      for (const key of Object.keys(usage)) bucket[key] += row[key];
+      models.set(model, bucket);
+      const at = date(entry?.timestamp);
+      if (at && (!firstActivity || Date.parse(at) < Date.parse(firstActivity))) firstActivity = at;
+      if (at && (!lastActivity || Date.parse(at) > Date.parse(lastActivity))) lastActivity = at;
+    }
+  } else if (agent === "codex" && raw.models && typeof raw.models === "object" && !Array.isArray(raw.models)) {
+    for (const [model, value] of Object.entries(raw.models)) {
+      models.set(model, { model, ...counters(value), missingPricing: value?.missingPricing === true });
+    }
+  } else return null;
+  // Per-model dollars are absent in Codex's JSON and Claude's entry costUSD
+  // may omit calculated costs. Keep the reported total; don't invent a split.
+  return {
+    sessionId, agent, speed, totalCost: raw.totalCost, totalTokens: raw.totalTokens,
+    ...usage, firstActivity, lastActivity, entries,
+    models: [...models.values()].map(row => ({ ...row, totalTokens: tokenTotal(row) }))
+      .sort((a, b) => b.totalTokens - a.totalTokens || a.model.localeCompare(b.model)),
+  };
+}

package/src/server/ccusage.mjs

@@ -12,6 +12,7 @@ import {
   backgroundUpdateDue, installsDisabled, maybeBackgroundUpdate, resolveEntry, startInstall,
 } from "./ccusage-install.mjs";
 import { overrideIsThere, runCcusage, userCcusage } from "./ccusage-runner.mjs";
+import { sessionDetail, validSessionLookup } from "./ccusage-session.mjs";
 
 // 60s, and it is the panel's poll interval rather than a number of its own: the
 // Usage panel asks once a minute and expects a reading that has actually moved,
@@ -295,6 +296,45 @@ export async function fetchCcusageDaily({ since, until, force = false } = {}) {
   return run;
 }
 
+/** A manual, whole-session read. Shares the history queue and its limits. */
+export async function fetchCcusageSession({ agent, sessionId, speed = "auto", force = false } = {}) {
+  if (!validSessionLookup(agent, sessionId, speed)) {
+    return { ok: false, reason: "bad_session", error: "Choose a Claude or Codex session and a supported pricing mode." };
+  }
+  const now = Date.now();
+  const key = `session:${agent}:${speed}:${sessionId}`;
+  const cached = _cache.get(key);
+  if (!force && cached && now - cached.at < CACHE_MS) return cached.result;
+  if (_inflight.has(key)) return _inflight.get(key);
+  if (_outstanding >= MAX_OUTSTANDING) {
+    return { ok: false, reason: "busy", error: "Usage reports are already being read. Try again in a moment." };
+  }
+  const run = queued(async () => {
+    let result;
+    try {
+      const args = [agent, "session", "--id", sessionId, "--json"];
+      // Auto is ccusage's default. Omitting the flag preserves older copies;
+      // explicit modes are scenarios and must never silently fall back.
+      if (agent === "codex" && speed !== "auto") args.push("--speed", speed);
+      const ran = await runCcusage(args);
+      const raw = ran.out.trim() === "null" ? null : extractJson(ran.out);
+      const detail = sessionDetail(raw, agent, sessionId, speed);
+      result = detail ? { ok: true, detail, fetchedAt: Date.now() }
+        : { ok: false, reason: raw == null ? "not_found" : "bad_output",
+          error: raw == null ? "No local usage was found for this session." : "ccusage returned an unsupported session report.", fetchedAt: Date.now() };
+    } catch (err) {
+      const error = String(err?.message ?? err);
+      const reason = err?.reason ?? (/No Codex session found with ID:/i.test(error) ? "not_found"
+        : /Codex session ID .* is ambiguous/i.test(error) ? "ambiguous" : "run_failed");
+      result = { ok: false, reason, error, fetchedAt: Date.now() };
+    }
+    rememberRange(key, result, Date.now());
+    return result;
+  }).finally(() => { _inflight.delete(key); });
+  _inflight.set(key, run);
+  return run;
+}
+
 /**
  * The same range, grouped by session rather than by day.
  *

package/src/server/index.mjs

@@ -162,9 +162,9 @@ import { cswapAutoModule, getProjectRollup, handleAccountLoginState, handleAccou
 // Browser Watch's three routes — see browser-watch-routes.mjs.
 import { handleBrowserWatch, handleBrowserWatchDismiss, handleBrowserWatchSettings } from "./browser-watch-routes.mjs";
 // The music routes, every one behind AGENTS_DECK_NO_MUSIC — see music-routes.mjs.
-import { handleBestOfNostalgia, handleCafeMusicBgm, handleClaudeFm, handleFmStation, handleGoodLifeRadio, handleLiveRadioMix, handleLofiGirl } from "./music-routes.mjs";
+import { handleBestOfNostalgia, handleCafeMusicBgm, handleClaudeFm, handleFmStation, handleGoodLifeRadio, handleLiveRadioMix, handleLofiGirl, handleRadioStations, handleRadioClick, handleMusicConfig } from "./music-routes.mjs";
 // The usage panel's quota and history reads — see usage-routes.mjs.
-import { handleCcusage, handleCodexQuota, handleCodexUsage, handleProviderStatus, handleQuota } from "./usage-routes.mjs";
+import { handleCcusage, handleCcusageSession, handleCodexQuota, handleCodexUsage, handleProviderStatus, handleQuota } from "./usage-routes.mjs";
 // The port fallback, one listen attempt, and the words for a failed one — see
 // listen.mjs. The loop that uses them is startServer's.
 import { listenFailure, portRetryable, randomPort, tryListen } from "./listen.mjs";
@@ -371,6 +371,7 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
     }
     if (req.method === "GET"  && url.pathname === "/api/codex-quota") return guard(handleCodexQuota(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/ccusage")     return guard(handleCcusage(req, res), res);
+    if (req.method === "GET"  && url.pathname === "/api/ccusage/session") return guard(handleCcusageSession(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/provider-status") return guard(handleProviderStatus(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/browser-watch") return guard(handleBrowserWatch(req, res), res);
     if (req.method === "POST" && url.pathname === "/api/browser-watch") return guard(handleBrowserWatchSettings(req, res), res);
@@ -383,6 +384,9 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
     if (req.method === "GET"  && url.pathname === "/api/cswap-auto")  return guard(handleCswapAuto(req, res), res);
     if (req.method === "POST" && url.pathname === "/api/cswap-auto")  return guard(handleCswapAutoAction(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/claude-fm")   return guard(handleClaudeFm(req, res), res);
+    if (req.method === "GET" && url.pathname === "/api/music-config") return handleMusicConfig(req, res);
+    if (req.method === "GET" && url.pathname === "/api/radio-stations") return guard(handleRadioStations(req, res), res);
+    if (req.method === "GET" && url.pathname === "/api/radio-click") return guard(handleRadioClick(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/fm-station") return guard(handleFmStation(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/lofi-girl")   return guard(handleLofiGirl(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/live-radio-mix") return guard(handleLiveRadioMix(req, res), res);

package/src/server/music-routes.mjs

@@ -132,3 +132,26 @@ export async function handleCafeMusicBgm(req, res) {
   const answer = await fetchCafeMusicBgm();
   send(res, answer ? 200 : 404, answer ?? { ok: false, error: "Cafe Music BGM is not live" });
 }
+
+export async function handleRadioStations(req, res) {
+  if (process.env.AGENTS_DECK_NO_MUSIC === "1") return send(res, 200, { ok: true, off: true, stations: [] });
+  const { radioDirectory } = await import(pathToFileURL(join(PKG_ROOT, "src/server/radio-directory.mjs")).href);
+  const query = new URL(req.url, "http://localhost").searchParams;
+  try {
+    const stations = await radioDirectory.search({ name: query.get("name") ?? "", country: query.get("country") ?? "", tag: query.get("tag") ?? "", language: query.get("language") ?? "" });
+    send(res, 200, { ok: true, stations });
+  } catch { send(res, 503, { ok: false, error: "directory_unavailable", stations: [] }); }
+}
+
+export async function handleRadioClick(req, res) {
+  if (process.env.AGENTS_DECK_NO_MUSIC === "1") return send(res, 200, { ok: true, off: true });
+  const id = new URL(req.url, "http://localhost").searchParams.get("id") ?? "";
+  if (!/^radio-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(id)) return send(res, 400, { ok: false });
+  const { radioDirectory } = await import(pathToFileURL(join(PKG_ROOT, "src/server/radio-directory.mjs")).href);
+  await radioDirectory.click(id);
+  send(res, 200, { ok: true });
+}
+
+export function handleMusicConfig(req, res) {
+  send(res, 200, { enabled: process.env.AGENTS_DECK_NO_MUSIC !== "1" });
+}

package/src/server/pinned-build.mjs

@@ -65,6 +65,7 @@ const PINNED_MODULES = [
   "browser-watch-store.mjs",
   "claude-fm.mjs",
   "fm-station.mjs",
+  "radio-directory.mjs",
   "lofi-girl.mjs",
   "live-radio-mix.mjs",
   "best-of-nostalgia.mjs",

package/src/server/radio-directory.mjs

@@ -0,0 +1,100 @@
+import { resolveSrv } from "node:dns/promises";
+
+const UUID = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i;
+const FALLBACK = ["de1.api.radio-browser.info", "nl1.api.radio-browser.info", "at1.api.radio-browser.info"];
+const TTL = 10 * 60_000;
+
+export function normalizeRadioStation(row) {
+  if (!row || typeof row !== "object" || !UUID.test(row.stationuuid)) return null;
+  let url;
+  try { url = new URL(row.url_resolved || row.url); } catch { return null; }
+  if (url.protocol !== "https:" || url.username || url.password || /\.(pls|m3u)$/i.test(url.pathname)) return null;
+  const name = String(row.name ?? "").trim().slice(0, 80);
+  if (!name) return null;
+  const coordinate = (value, limit) => typeof value === "number" && Number.isFinite(value) && Math.abs(value) <= limit ? value : null;
+  return {
+    id: `radio-${row.stationuuid}`, name, url: url.href,
+    country: String(row.country ?? "").slice(0, 80), countryCode: String(row.countrycode ?? "").slice(0, 2),
+    region: String(row.state ?? "").slice(0, 80), tags: String(row.tags ?? "").slice(0, 180),
+    language: String(row.language ?? "").slice(0, 80), codec: String(row.codec ?? "").slice(0, 12),
+    bitrate: Math.max(0, Math.min(1000, Number(row.bitrate) || 0)),
+    ...(row.hls === 1 ? { hls: true } : {}),
+    lat: coordinate(row.geo_lat, 90), lon: coordinate(row.geo_long, 180),
+  };
+}
+
+export function createRadioDirectory({ fetchImpl = fetch, discover = resolveSrv, now = Date.now, random = Math.random } = {}) {
+  const cache = new Map();
+  const pending = new Map();
+  const clicks = new Set();
+  let hosts;
+  let hostTime = 0;
+  async function servers() {
+    if (hosts && now() - hostTime < TTL) return hosts;
+    try {
+      const rows = await Promise.race([
+        discover("_api._tcp.radio-browser.info"),
+        new Promise((_, reject) => { const timer = setTimeout(() => reject(new Error("dns_timeout")), 2000); timer.unref?.(); }),
+      ]);
+      hosts = rows.map(row => row.name.replace(/\.$/, "")).filter(host => /^[a-z0-9-]+\.api\.radio-browser\.info$/i.test(host));
+    } catch { hosts = []; }
+    hosts = [...new Set([...hosts, ...FALLBACK])];
+    for (let i = hosts.length - 1; i > 0; i--) { const j = Math.floor(random() * (i + 1)); [hosts[i], hosts[j]] = [hosts[j], hosts[i]]; }
+    hostTime = now();
+    return hosts;
+  }
+  async function request(path) {
+    for (const host of (await servers()).slice(0, 3)) {
+      try {
+        const response = await fetchImpl(`https://${host}${path}`, {
+          headers: { "User-Agent": "ccdeck-radio/1.0 (+https://ccdeck.dev)", Accept: "application/json" },
+          signal: AbortSignal.timeout(4500), redirect: "error",
+        });
+        if (!response.ok) throw new Error("directory_unavailable");
+        const reader = response.body?.getReader();
+        if (!reader) return await response.json();
+        const chunks = []; let size = 0;
+        try {
+          for (;;) { const { done, value } = await reader.read(); if (done) break; size += value.byteLength; if (size > 2_000_000) throw new Error("directory_too_large"); chunks.push(value); }
+        } finally { await reader.cancel().catch(() => {}); }
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      } catch { /* Try another directory mirror, never another stream. */ }
+    }
+    throw new Error("directory_unavailable");
+  }
+  async function search({ name = "", country = "", tag = "", language = "" } = {}) {
+    const params = new URLSearchParams({ limit: "300", hidebroken: "true", order: "clickcount", reverse: "true", is_https: "true" });
+    if (name) params.set("name", name.trim().slice(0, 80));
+    if (country) params.set("countrycode", country.toUpperCase().slice(0, 2));
+    if (tag) params.set("tag", tag.trim().slice(0, 40));
+    if (language) params.set("language", language.trim().slice(0, 40));
+    const key = params.toString();
+    const cached = cache.get(key);
+    if (cached && now() - cached.at < TTL) return cached.stations;
+    if (pending.has(key)) return pending.get(key);
+    const promise = request(`/json/stations/search?${key}`).then(rows => {
+      if (!Array.isArray(rows)) throw new Error("directory_invalid");
+      const seen = new Set();
+      const stations = rows.slice(0, 300).map(normalizeRadioStation).filter(station => {
+        if (!station || seen.has(station.id)) return false;
+        seen.add(station.id); return true;
+      });
+      if (cache.size >= 64) cache.delete(cache.keys().next().value);
+      cache.set(key, { at: now(), stations });
+      return stations;
+    }).finally(() => pending.delete(key));
+    pending.set(key, promise);
+    return promise;
+  }
+  async function click(id) {
+    const uuid = id.replace(/^radio-/, "");
+    if (!UUID.test(uuid)) return false;
+    if (clicks.has(uuid)) return true;
+    if (clicks.size >= 1000) clicks.clear();
+    clicks.add(uuid);
+    try { await request(`/json/url/${uuid}`); return true; } catch { clicks.delete(uuid); return false; }
+  }
+  return { search, click };
+}
+
+export const radioDirectory = createRadioDirectory();

package/src/server/request-gates.mjs

@@ -455,6 +455,7 @@ export const GUARDED_READS = new Set([
   // the desktop app, bin/ and the hook never read them.
   "/api/quota",
   "/api/ccusage",
+  "/api/ccusage/session",
   "/api/codex-usage",
   "/api/cswap-auto",
   // Not a secret, and here for the other reason a read can be dangerous: it is
@@ -464,6 +465,8 @@ export const GUARDED_READS = new Set([
   // only caller that needs it is the deck's own canvas, which sends
   // Sec-Fetch-Site: same-origin on every fetch.
   "/api/fm-station",
+  "/api/radio-stations",
+  "/api/radio-click",
 ]);
 
 export function isAuthorizedMutation(req) {

package/src/server/transcript-scan.mjs

@@ -193,6 +193,17 @@ function billedSpeed(record) {
   return typeof speed === "string" && SPEED_VALUE_RE.test(speed) ? speed : UNRECOGNISED_SPEED;
 }
 
+/** Haiku 5.5's request tier includes uncached input, cache reads and writes.
+ *  The threshold is strictly greater than 100K, independently for each request.
+ *  https://platform.claude.com/docs/en/about-claude/pricing (2026-10-12). */
+function isLongContextRequest(model, usage) {
+  const bare = typeof model === "string"
+    ? model.replace(/^(?:(?:us-gov|global|apac|us|eu|jp|au)\.)?anthropic\./i, "") : "";
+  if (!/^claude[-_]haiku[-_]5[-_.]5\b(?![-_.]\d{1,7}(?!\d))/i.test(bare)) return false;
+  return tokenCount(usage?.input_tokens) + tokenCount(usage?.cache_read_input_tokens)
+    + tokenCount(usage?.cache_creation_input_tokens) > 100_000;
+}
+
 /** The share of `bucket` billed at `speed`, created on first sight. Null for
  *  the standard speed or a bucket we could not attribute. `Object.hasOwn`
  *  rather than a plain read, because `constructor` passes SPEED_VALUE_RE and
@@ -268,10 +279,14 @@ function tokenCount(v) {
 /** Add one bucket's counters, and its speed shares, into `dst`. */
 function addUsageBucket(dst, src) {
   for (const k of USAGE_TOTAL_FIELDS) dst[k] += src[k] ?? 0;
+  if (src.longContext) {
+    const into = dst.longContext ??= newUsageTotals();
+    for (const k of USAGE_TOTAL_FIELDS) into[k] += src.longContext[k] ?? 0;
+  }
   if (!src.speeds) return dst;
   for (const [speed, share] of Object.entries(src.speeds)) {
     const into = speedBucketFor(dst, speed);
-    for (const k of USAGE_TOTAL_FIELDS) into[k] += share[k] ?? 0;
+    addUsageBucket(into, share);
   }
   return dst;
 }
@@ -617,6 +632,8 @@ function foldUsageLine(state, line, record) {
   // and the two would stop summing to each other.
   const bucket = usageBucketFor(state, state.lastModel);
   const speedBucket = speedBucketFor(bucket, billedSpeed(record));
+  const longBuckets = isLongContextRequest(state.lastModel, record?.message?.usage)
+    ? [bucket, speedBucket].filter(Boolean).map(b => b.longContext ??= newUsageTotals()) : [];
   const charged = newUsageTotals();
   if (billing === BILL_LINE) {
     const billed = billedUsageText(line);
@@ -626,23 +643,26 @@ function foldUsageLine(state, line, record) {
     for (const m of billed.replace(ITERATIONS_ARRAY_RE, "").matchAll(CACHE_CREATION_BLOCK_RE)) {
       chargeUsage(state, bucket, m[1], CACHE_SPLIT_FIELDS, speedBucket, charged);
     }
+    for (const into of longBuckets) addUsageBucket(into, charged);
     return;
   }
   chargeRequestUsage(state, bucket, record.message?.usage, speedBucket, charged);
+  for (const into of longBuckets) addUsageBucket(into, charged);
   // What this request was charged, and where, kept until its final record
   // replaces it.
   const id = streamingRequestId(record);
-  ledger.streaming = id === null ? null : { id, bucket, speedBucket, charged };
+  ledger.streaming = id === null ? null : { id, bucket, speedBucket, longBuckets, charged };
 }
 
 /** Take back what a request was charged, from every counter it was charged
  *  to, for its later record to charge in its place. */
-function refundUsage(state, { bucket, speedBucket, charged }) {
+function refundUsage(state, { bucket, speedBucket, longBuckets = [], charged }) {
   for (const k of USAGE_TOTAL_FIELDS) {
     const n = charged[k];
     state.usage[k] -= n;
     if (bucket) bucket[k] -= n;
     if (speedBucket) speedBucket[k] -= n;
+    for (const into of longBuckets) into[k] -= n;
   }
 }
 
@@ -828,5 +848,5 @@ function scanTranscript(path) {
 export {
   scanTranscript, newUsageTotals, hasSpend, mergeUsageByModel, copyUsageBucket,
   requestBilling, newRequestLedger, noteRequestRecord, streamingRequestId,
-  BILL_LINE, REBILL_REQUEST, SKIP_LINE, billedSpeed, MAX_SPEEDS_PER_MODEL, UNRECOGNISED_SPEED,
+  BILL_LINE, REBILL_REQUEST, SKIP_LINE, billedSpeed, isLongContextRequest, MAX_SPEEDS_PER_MODEL, UNRECOGNISED_SPEED,
 };

package/src/server/usage-routes.mjs

@@ -12,6 +12,7 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { deckProviders } from "./deck-scope.mjs";
 import { send } from "./http-io.mjs";
+import { validSessionLookup } from "./ccusage-session.mjs";
 
 // Resolved the way pinned-build.mjs resolves it, from a file in the same
 // directory, so every lazy import below is the URL the pin has already evaluated.
@@ -106,3 +107,15 @@ export async function handleCcusage(req, res) {
   const data = await fetchCcusageDaily({ since, until, force });
   send(res, 200, data);
 }
+
+export async function handleCcusageSession(req, res) {
+  const url = new URL(req.url, "http://localhost");
+  const agent = url.searchParams.get("agent");
+  const sessionId = url.searchParams.get("id");
+  const speed = url.searchParams.get("speed") ?? "auto";
+  if (!validSessionLookup(agent, sessionId, speed)) {
+    return send(res, 400, { ok: false, reason: "bad_session", error: "Invalid session lookup." });
+  }
+  const { fetchCcusageSession } = await import(pathToFileURL(join(PKG_ROOT, "src/server/ccusage.mjs")).href);
+  send(res, 200, await fetchCcusageSession({ agent, sessionId, speed, force: url.searchParams.get("refresh") === "1" }));
+}