@oar-sh/oar 0.9.6 → 0.9.7

package/server/services/git-remote-service.mjs

@@ -0,0 +1,115 @@
+'use strict';
+
+import { execFile as nodeExecFile } from 'child_process';
+
+import { normalizeGitHubRepoUrl } from '../../shared/claude-cloud/repo-url.mjs';
+import { createGitChangesService } from './git-changes-service.mjs';
+
+// What a folder's git checkout says about where it lives on GitHub: the
+// remote, the branch, and how far the checkout is from what was pushed. The
+// New Chat modal fills the repository and branch of a Claude Cloud chat from
+// it and warns about work the cloud clone will not have (commits that were
+// never pushed, uncommitted changes).
+//
+// Read-only: `git status` and `git remote get-url`, nothing else. The route
+// validates the folder before calling in.
+
+const GIT_COMMAND_TIMEOUT_MS = 15_000;
+const DEFAULT_REMOTE = 'origin';
+
+const NO_GIT = Object.freeze({
+  hasGit: false,
+  remoteUrl: null,
+  repoUrl: null,
+  slug: null,
+  branch: null,
+  upstream: null,
+  ahead: 0,
+  behind: 0,
+  dirty: false,
+});
+
+/**
+ * A remote URL as the browser may see it: credentials in front of the host
+ * (`https://user:secret@host/…`) are dropped. The scp form keeps its `git@`.
+ */
+export function redactRemoteUrlCredentials(remoteUrl) {
+  const text = String(remoteUrl || '').trim();
+  if (!text) return '';
+  if (!/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(text)) return text;
+  try {
+    const url = new URL(text);
+    if (!url.username && !url.password) return text;
+    // ssh://git@host/… names the transport user, not a secret.
+    if (url.protocol === 'ssh:' && !url.password) return text;
+    url.username = '';
+    url.password = '';
+    return url.toString();
+  } catch {
+    return text.replace(/\/\/[^/@\s]*@/, '//');
+  }
+}
+
+/** The remote a tracking ref such as `fork/main` lives on, or ''. */
+function remoteOfUpstream(upstream) {
+  const text = String(upstream || '').trim();
+  const slash = text.indexOf('/');
+  return slash > 0 ? text.slice(0, slash) : '';
+}
+
+export function createGitRemoteService({
+  execFileImpl = nodeExecFile,
+  gitChangesService = createGitChangesService({ execFileImpl }),
+} = {}) {
+  function readRemoteUrl(rootPath, remoteName) {
+    return new Promise((resolve) => {
+      try {
+        execFileImpl('git', ['remote', 'get-url', remoteName], {
+          cwd: rootPath,
+          timeout: GIT_COMMAND_TIMEOUT_MS,
+          windowsHide: true,
+        }, (error, stdout) => {
+          // No such remote is an answer, not a failure.
+          resolve(error ? '' : String(stdout || '').trim().split(/\r?\n/)[0] || '');
+        });
+      } catch {
+        resolve('');
+      }
+    });
+  }
+
+  /**
+   * `{ ok, hasGit, remoteUrl, repoUrl, slug, branch, upstream, ahead, behind,
+   * dirty }` for a folder; `hasGit: false` when it is not a git checkout.
+   */
+  async function describe(rootPath) {
+    const status = await gitChangesService.getStatus(rootPath);
+    if (!status?.ok) return { ok: false, error: status?.error || 'Failed to read git status' };
+    if (status.isRepo === false) return { ok: true, ...NO_GIT };
+
+    const upstream = String(status.upstream || '').trim();
+    let remoteUrl = await readRemoteUrl(rootPath, DEFAULT_REMOTE);
+    const upstreamRemote = remoteOfUpstream(upstream);
+    if (!remoteUrl && upstreamRemote && upstreamRemote !== DEFAULT_REMOTE) {
+      remoteUrl = await readRemoteUrl(rootPath, upstreamRemote);
+    }
+    // One validator for the modal and for the bootstrap that follows it: a
+    // remote the bootstrap would refuse is shown as "no GitHub remote".
+    const repo = normalizeGitHubRepoUrl(remoteUrl);
+    const branch = status.detached ? '' : String(status.branch || '').trim();
+    return {
+      ok: true,
+      hasGit: true,
+      remoteUrl: redactRemoteUrlCredentials(remoteUrl) || null,
+      repoUrl: repo?.repoUrl || null,
+      slug: repo?.slug || null,
+      branch: branch || null,
+      upstream: upstream || null,
+      ahead: Number(status.ahead || 0),
+      behind: Number(status.behind || 0),
+      dirty: Array.isArray(status.files) && status.files.length > 0,
+    };
+  }
+
+  return { describe };
+}

package/server/services/plan-usage-claude-cloud.mjs

@@ -0,0 +1,211 @@
+'use strict';
+
+/**
+ * Claude Cloud usage (provider `claude-cloud`).
+ *
+ * Cloud sessions are billed to the Claude account: a dollar credit is spent
+ * first where the account holds one, and without it the turns count against
+ * the same 5-hour and weekly windows the Claude card shows. So this card has
+ * no windows of its own. It shows
+ *  - the dollar buckets of the live account usage (the credit and its expiry),
+ *  - what the relay's own cloud conversations have cost, as Anthropic reported
+ *    it per session (the relay keeps the latest figure per conversation; there
+ *    is no account-wide total to ask for),
+ *  - the session detail of the latest cloud worker report.
+ *
+ * The credit arrives under an internal codename that may change, so every
+ * top-level bucket of the usage body that carries a dollar limit is a meter;
+ * the codename table only supplies a nicer label.
+ */
+
+import {
+  SOURCE_LIVE,
+  SOURCE_WORKER,
+  STATUS_OK,
+  STATUS_PARTIAL,
+  STATUS_UNAVAILABLE,
+  buildDetailSection,
+  buildMeter,
+  buildProviderCard,
+  pickNonNegative,
+  toFiniteNumber,
+  toIsoTimestamp,
+  toTrimmedString,
+} from './plan-usage-contract.mjs';
+import { CLAUDE_USAGE_URL, buildClaudeSessionSections, formatClaudeMoney } from './plan-usage-claude.mjs';
+
+export const CLAUDE_CLOUD_PROVIDER_ID = 'claude-cloud';
+export const CLAUDE_CLOUD_LABEL = 'Claude Cloud';
+
+const CLAUDE_CODE_WEB_URL = 'https://claude.ai/code';
+
+// Null-prototype: the keys come from an API body.
+const DOLLAR_BUCKET_LABELS = Object.freeze(Object.assign(Object.create(null), {
+  iguana_necktie: 'Cloud sessions credit',
+}));
+
+/** "maple_sprocket" → "Maple sprocket credit": the label of a bucket the table does not know. */
+export function humanizeDollarBucketKey(key) {
+  const words = String(key ?? '').replace(/[^A-Za-z0-9]+/g, ' ').trim().toLowerCase();
+  if (!words) return 'Credit';
+  return `${words.charAt(0).toUpperCase()}${words.slice(1)} credit`;
+}
+
+/**
+ * The dollar buckets of an account usage body, in the body's order: every
+ * top-level value that is an object with a numeric `limit_dollars`.
+ */
+export function listClaudeDollarBuckets(usageBody) {
+  if (!usageBody || typeof usageBody !== 'object' || Array.isArray(usageBody)) return [];
+  const buckets = [];
+  for (const [key, value] of Object.entries(usageBody)) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) continue;
+    const limitUsd = toFiniteNumber(value.limit_dollars);
+    if (limitUsd === null) continue;
+    buckets.push({
+      key,
+      label: DOLLAR_BUCKET_LABELS[key] || humanizeDollarBucketKey(key),
+      limitUsd,
+      usedUsd: toFiniteNumber(value.used_dollars),
+      remainingUsd: toFiniteNumber(value.remaining_dollars),
+      utilization: toFiniteNumber(value.utilization),
+      expiresAt: toIsoTimestamp(value.resets_at),
+    });
+  }
+  return buckets;
+}
+
+/**
+ * What the credit-offer answer says: `{ open, amount }`, where `amount` is
+ * the formatted sum when the answer names one. An offer that was granted
+ * already is not open.
+ */
+export function describeClaudeCreditOffer(offer) {
+  if (!offer || typeof offer !== 'object') return { open: false, amount: null };
+  const open = (offer.available === true || offer.eligible === true) && offer.granted !== true;
+  const minor = toFiniteNumber(offer.amount_minor_units);
+  const amount = minor !== null && minor > 0 ? formatClaudeMoney(minor / 100, offer.currency) : null;
+  return { open, amount };
+}
+
+/**
+ * @param {object} options
+ * @param {object|null} options.account  live account usage (`{ usage, prepaid,
+ *   offer, fetchedAt, error }`), or null when it was not read
+ * @param {object|null} options.spend    what the relay recorded: `{ totalUsd,
+ *   conversationCount, conversation: { costUsd } | null }` (`conversation` is
+ *   the one the modal was opened from, when it is a cloud conversation)
+ * @param {object|null} options.usage    the latest `claude-cloud` snapshot
+ * @param {string|null} options.capturedAt  when that snapshot was stored
+ * @param {boolean} options.configured   Claude Cloud provider enabled
+ */
+export function buildClaudeCloudPlanCard({
+  account = null,
+  spend = null,
+  usage = null,
+  capturedAt = null,
+  configured = true,
+} = {}) {
+  // Opt-in like Grok: no card at all while the provider is off.
+  if (!configured) return null;
+
+  const hasAccount = !!account?.usage && typeof account.usage === 'object';
+  const buckets = hasAccount ? listClaudeDollarBuckets(account.usage) : [];
+  const meters = buckets.map((bucket) => buildMeter({
+    id: `claude-cloud-credit-${bucket.key.replace(/[^A-Za-z0-9_]+/g, '-')}`,
+    label: bucket.label,
+    unit: 'usd',
+    used: bucket.usedUsd,
+    allowance: bucket.limitUsd,
+    remaining: bucket.remainingUsd,
+    // The dollars are exact; the percentage only stands in when they are missing.
+    utilization: bucket.usedUsd === null && bucket.remainingUsd === null ? bucket.utilization : null,
+    resetAt: bucket.expiresAt,
+    resetKind: 'expiry',
+    emphasis: 'primary',
+  })).filter(Boolean);
+  const hasCredit = meters.length > 0;
+
+  const details = [];
+  const conversationCount = Math.max(0, Math.round(toFiniteNumber(spend?.conversationCount) || 0));
+  if (conversationCount > 0) {
+    const totalUsd = pickNonNegative(spend?.totalUsd) ?? 0;
+    const countText = `${conversationCount} cloud conversation${conversationCount === 1 ? '' : 's'}`;
+    meters.push(buildMeter({
+      id: 'claude-cloud-spend',
+      label: 'Cloud spend (OAR sessions)',
+      unit: 'usd',
+      used: totalUsd,
+      emphasis: hasCredit ? 'secondary' : 'primary',
+      note: `${countText} on this relay. Anthropic’s reported cost, not a billing statement.`,
+    }));
+    const rows = [{ label: 'All cloud conversations', value: formatClaudeMoney(totalUsd), hint: countText }];
+    if (spend?.conversation && typeof spend.conversation === 'object') {
+      const cost = pickNonNegative(spend.conversation.costUsd);
+      rows.push({
+        label: 'This conversation',
+        value: cost === null ? '—' : formatClaudeMoney(cost),
+        hint: cost === null ? 'No cost reported yet' : null,
+      });
+    }
+    details.push(buildDetailSection({
+      id: 'claude-cloud-spend',
+      label: 'Cloud spend (OAR sessions)',
+      note: 'The cost Anthropic reports per cloud session, summed over the cloud conversations this relay still has. Not a billing statement; sessions started elsewhere are not included.',
+      rows,
+    }));
+  }
+
+  details.push(...buildClaudeSessionSections(usage?.session, {
+    idPrefix: 'claude-cloud',
+    sessionLabel: 'Latest cloud session report',
+    modelsLabel: 'By model (latest cloud session report)',
+    costLabel: 'Reported cost',
+    costHint: 'Anthropic’s reported cost, not a billing statement',
+  }));
+
+  const notes = [];
+  const offer = describeClaudeCreditOffer(account?.offer);
+  if (!hasCredit && offer.open) {
+    notes.push({
+      id: 'claude-cloud-credit-offer',
+      text: offer.amount
+        ? `A cloud credit of ${offer.amount} is available to claim on claude.ai.`
+        : 'A cloud credit is available to claim on claude.ai.',
+      link: { label: 'Open the usage page', url: CLAUDE_USAGE_URL },
+    });
+  }
+  notes.push({
+    id: 'claude-cloud-billing',
+    text: 'Cloud turns spend the cloud credit first; without a credit they count against the Claude limits (5-hour and weekly).',
+  });
+
+  const resolvedMeters = meters.filter(Boolean);
+  const resolvedDetails = details.filter(Boolean);
+  let status = STATUS_OK;
+  let message = null;
+  if (!hasAccount) {
+    status = resolvedMeters.length || resolvedDetails.length ? STATUS_PARTIAL : STATUS_UNAVAILABLE;
+    message = ['The account usage could not be read, so a cloud credit is not shown.', toTrimmedString(account?.error)]
+      .filter(Boolean)
+      .join(' ');
+  } else if (!resolvedMeters.length) {
+    message = 'This account holds no cloud credit, and no cloud conversation on this relay has run yet.';
+  }
+
+  return buildProviderCard({
+    provider: CLAUDE_CLOUD_PROVIDER_ID,
+    label: CLAUDE_CLOUD_LABEL,
+    status,
+    message,
+    source: hasAccount ? SOURCE_LIVE : SOURCE_WORKER,
+    capturedAt: hasAccount ? (toIsoTimestamp(account.fetchedAt) || capturedAt) : capturedAt,
+    meters: resolvedMeters,
+    details: resolvedDetails,
+    notes,
+    links: [
+      { label: 'Claude usage settings', url: CLAUDE_USAGE_URL },
+      { label: 'Claude Code on the web', url: CLAUDE_CODE_WEB_URL },
+    ],
+  });
+}

package/server/services/plan-usage-claude.mjs

@@ -13,10 +13,18 @@
  * When the experimental call is unavailable the worker still reports the
  * stable `modelUsage` / `total_cost_usd` result fields, which render as session
  * cost details with no plan meters.
+ *
+ * A second, live source exists while the Claude Cloud provider is switched on
+ * (the switch is the consent to use the Claude CLI's login): the account's
+ * usage as claude.ai's own endpoint reports it, read without a model turn
+ * (`claude-account-usage-service.mjs`). It carries the same window keys, so
+ * the meters are then built from it and the SDK snapshot only supplies the
+ * session details.
  */
 
 import {
   SOURCE_CACHE,
+  SOURCE_LIVE,
   SOURCE_WORKER,
   STATUS_NOT_CONFIGURED,
   STATUS_OK,
@@ -30,13 +38,14 @@ import {
   roundCurrency,
   toFiniteNumber,
   toIsoTimestamp,
+  toSeverity,
   toTrimmedString,
 } from './plan-usage-contract.mjs';
 
 export const CLAUDE_PROVIDER_ID = 'claude';
 export const CLAUDE_LABEL = 'Claude';
 
-const CLAUDE_USAGE_URL = 'https://claude.ai/settings/usage';
+export const CLAUDE_USAGE_URL = 'https://claude.ai/settings/usage';
 
 // Fixed windows, in display order. Model-scoped windows are appended after
 // these from the server-supplied `model_scoped[]` array.
@@ -139,7 +148,7 @@ export function normalizeClaudePlanUsage(raw) {
       const displayName = toTrimmedString(entry?.display_name);
       if (!normalized || !displayName) continue;
       windows.push({
-        id: `model_scoped:${displayName.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`,
+        id: modelScopedWindowId(displayName),
         label: `Weekly ${displayName}`,
         emphasis: 'secondary',
         ...normalized,
@@ -157,6 +166,7 @@ export function normalizeClaudePlanUsage(raw) {
       usedCredits: toFiniteNumber(rawExtra.used_credits),
       utilization: clampPercent(rawExtra.utilization),
       currency: toTrimmedString(rawExtra.currency),
+      decimalPlaces: toFiniteNumber(rawExtra.decimal_places),
     }
     : null;
 
@@ -184,6 +194,75 @@ export function normalizeClaudePlanUsage(raw) {
   return hasSignal ? payload : null;
 }
 
+function modelScopedWindowId(displayName) {
+  return `model_scoped:${displayName.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`;
+}
+
+// `limits[]` of the account endpoint names the two fixed windows by kind.
+const LIMIT_KIND_WINDOW_IDS = Object.freeze({ session: 'five_hour', weekly_all: 'seven_day' });
+
+/**
+ * Normalize the live account usage (the body of claude.ai's usage endpoint).
+ *
+ * Its top level is what the SDK response carries under `rate_limits`, so the
+ * windows and the extra usage come from the same normalizer. On top of that:
+ * `limits[]` adds a severity per window and the model-scoped weekly windows,
+ * and `seven_day_breakdown.rows` says which product the week went to.
+ * Returns `{ windows, extraUsage, breakdown }`, or null when nothing usable
+ * is present.
+ */
+export function normalizeClaudeAccountUsage(body) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return null;
+  const base = normalizeClaudePlanUsage({ rate_limits: body, rate_limits_available: true });
+  const windows = (base?.windows || []).map((window) => ({ ...window, severity: null }));
+
+  for (const entry of (Array.isArray(body.limits) ? body.limits : [])) {
+    if (!entry || typeof entry !== 'object') continue;
+    const kind = toTrimmedString(entry.kind);
+    let target = null;
+    if (kind === 'weekly_scoped') {
+      const displayName = toTrimmedString(entry.scope?.model?.display_name)
+        || toTrimmedString(entry.scope?.surface?.display_name);
+      if (!displayName) continue;
+      const label = `Weekly ${displayName}`;
+      target = windows.find((window) => window.label.toLowerCase() === label.toLowerCase()) || null;
+      if (!target) {
+        const reading = normalizeWindow({ utilization: entry.percent, resets_at: entry.resets_at });
+        if (!reading) continue;
+        target = { id: modelScopedWindowId(displayName), label, emphasis: 'secondary', ...reading, severity: null };
+        windows.push(target);
+      }
+    } else if (kind && LIMIT_KIND_WINDOW_IDS[kind]) {
+      target = windows.find((window) => window.id === LIMIT_KIND_WINDOW_IDS[kind]) || null;
+    }
+    if (target) target.severity = toSeverity(entry.severity);
+  }
+
+  const breakdown = (Array.isArray(body.seven_day_breakdown?.rows) ? body.seven_day_breakdown.rows : [])
+    .map((row) => {
+      const name = toTrimmedString(row?.display_name) || toTrimmedString(row?.key);
+      const percent = clampPercent(row?.percent);
+      return name && percent !== null ? { name, percent } : null;
+    })
+    .filter(Boolean);
+
+  const extraUsage = base?.extraUsage || null;
+  if (!windows.length && !extraUsage && !breakdown.length) return null;
+  return { windows, extraUsage, breakdown };
+}
+
+/**
+ * The prepaid credits of the organisation as `{ amount, currency }` in major
+ * units, or null. The API sends the balance as `amount` in minor units (the
+ * Claude CLI reads it as cents).
+ */
+export function normalizeClaudePrepaidCredits(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const minor = toFiniteNumber(raw.amount);
+  if (minor === null) return null;
+  return { amount: minor / 100, currency: toTrimmedString(raw.currency) };
+}
+
 /** Build the fallback payload from the stable result-message fields. */
 export function claudePlanUsageFromResult({ modelUsage = null, totalCostUsd = null } = {}) {
   const models = normalizeModelUsageMap(modelUsage);
@@ -232,6 +311,68 @@ function formatUsd(value) {
   return numeric === null ? null : `$${numeric.toFixed(2)}`;
 }
 
+/** "$12.50" for dollars (or an unnamed currency), "12.50 EUR" for any other. */
+export function formatClaudeMoney(amount, currency = null) {
+  const numeric = roundCurrency(amount);
+  if (numeric === null) return null;
+  const code = toTrimmedString(currency)?.toUpperCase() || 'USD';
+  return code === 'USD' ? `$${numeric.toFixed(2)}` : `${numeric.toFixed(2)} ${code}`;
+}
+
+/**
+ * Extra-usage amounts arrive in minor units of the currency (cents for USD;
+ * the SDK's response schema says so, and the account endpoint names the
+ * exponent in `decimal_places`).
+ */
+function extraUsageAmount(value, decimalPlaces) {
+  const numeric = toFiniteNumber(value);
+  if (numeric === null) return null;
+  const places = Number.isInteger(decimalPlaces) && decimalPlaces >= 0 && decimalPlaces <= 4 ? decimalPlaces : 2;
+  return numeric / (10 ** places);
+}
+
+/**
+ * The detail sections for one session's totals (`session` as
+ * `normalizeClaudePlanUsage` / `claudePlanUsageFromResult` store it). The
+ * Claude Cloud card shows its own latest snapshot through the same sections,
+ * under its own ids and wording.
+ */
+export function buildClaudeSessionSections(session, {
+  idPrefix = 'claude',
+  sessionLabel = 'Latest session totals',
+  modelsLabel = 'By model (session)',
+  costLabel = 'Session cost (estimate)',
+  costHint = 'Client-side estimate, not a billing statement',
+} = {}) {
+  if (!session || typeof session !== 'object') return [];
+  const sections = [];
+  const rows = [];
+  const cost = formatUsd(session.totalCostUsd);
+  if (cost) rows.push({ label: costLabel, value: cost, hint: costHint });
+  const apiDuration = formatDuration(session.totalApiDurationMs);
+  if (apiDuration) rows.push({ label: 'API time', value: apiDuration });
+  const wallDuration = formatDuration(session.totalDurationMs);
+  if (wallDuration) rows.push({ label: 'Wall-clock time', value: wallDuration });
+  if (toFiniteNumber(session.totalLinesAdded) !== null) rows.push({ label: 'Lines added', value: String(session.totalLinesAdded) });
+  if (toFiniteNumber(session.totalLinesRemoved) !== null) rows.push({ label: 'Lines removed', value: String(session.totalLinesRemoved) });
+  const sessionSection = buildDetailSection({ id: `${idPrefix}-session`, label: sessionLabel, rows });
+  if (sessionSection) sections.push(sessionSection);
+
+  const modelRows = (Array.isArray(session.modelUsage) ? session.modelUsage : []).map((entry) => ({
+    label: entry.model,
+    value: formatUsd(entry.costUsd) ?? '—',
+    hint: [
+      formatTokens(entry.inputTokens) ? `in ${formatTokens(entry.inputTokens)}` : null,
+      formatTokens(entry.outputTokens) ? `out ${formatTokens(entry.outputTokens)}` : null,
+      formatTokens(entry.cacheReadTokens) ? `cache r ${formatTokens(entry.cacheReadTokens)}` : null,
+      formatTokens(entry.cacheWriteTokens) ? `cache w ${formatTokens(entry.cacheWriteTokens)}` : null,
+    ].filter(Boolean).join(' · ') || null,
+  }));
+  const modelSection = buildDetailSection({ id: `${idPrefix}-models`, label: modelsLabel, rows: modelRows });
+  if (modelSection) sections.push(modelSection);
+  return sections;
+}
+
 function attributionRows(entries, limit = 6) {
   return entries.slice(0, limit).map((entry) => ({
     label: entry.name,
@@ -280,12 +421,20 @@ function behaviorSections(behaviors) {
   return sections;
 }
 
+/**
+ * @param {object} options
+ * @param {object|null} options.usage     the stored snapshot of the last SDK turn
+ * @param {object|null} options.account   live account usage
+ *   (`{ usage, prepaid, offer, fetchedAt, error }` from
+ *   claude-account-usage-service.mjs), or null when it was not read
+ */
 export function buildClaudePlanCard({
   usage = null,
   capturedAt = null,
   stale = false,
   configured = true,
   message = null,
+  account = null,
 } = {}) {
   if (!configured) {
     return buildUnavailableCard({
@@ -295,7 +444,11 @@ export function buildClaudePlanCard({
       message: 'Claude is not enabled in provider settings.',
     });
   }
-  if (!usage) {
+  const live = normalizeClaudeAccountUsage(account?.usage);
+  // Live windows replace the snapshot's; a live answer without a single
+  // window (it should not happen for a plan login) leaves the snapshot in place.
+  const hasLive = !!live && live.windows.length > 0;
+  if (!usage && !hasLive) {
     return buildUnavailableCard({
       provider: CLAUDE_PROVIDER_ID,
       label: CLAUDE_LABEL,
@@ -307,7 +460,8 @@ export function buildClaudePlanCard({
   }
 
   const meters = [];
-  for (const window of (Array.isArray(usage.windows) ? usage.windows : [])) {
+  const windows = hasLive ? live.windows : (Array.isArray(usage.windows) ? usage.windows : []);
+  for (const window of windows) {
     meters.push(buildMeter({
       id: `claude-${window.id}`,
       label: window.label,
@@ -315,17 +469,18 @@ export function buildClaudePlanCard({
       utilization: window.utilization,
       resetAt: window.resetsAt,
       emphasis: window.emphasis === 'secondary' ? 'secondary' : 'primary',
+      severity: window.severity,
     }));
   }
 
-  const extra = usage.extraUsage;
+  const extra = hasLive ? live.extraUsage : usage.extraUsage;
   if (extra && (extra.isEnabled || extra.usedCredits !== null || extra.monthlyLimit !== null)) {
     meters.push(buildMeter({
       id: 'claude-extra-usage',
       label: 'Extra usage credits',
       unit: extra.currency && extra.currency.toUpperCase() !== 'USD' ? 'credits' : 'usd',
-      used: extra.usedCredits,
-      allowance: extra.monthlyLimit,
+      used: extraUsageAmount(extra.usedCredits, extra.decimalPlaces),
+      allowance: extraUsageAmount(extra.monthlyLimit, extra.decimalPlaces),
       utilization: extra.utilization,
       note: extra.isEnabled ? null : 'Extra usage is disabled for this account',
       emphasis: 'secondary',
@@ -333,55 +488,62 @@ export function buildClaudePlanCard({
   }
 
   const details = [];
-  const session = usage.session;
-  if (session) {
-    const rows = [];
-    const cost = formatUsd(session.totalCostUsd);
-    if (cost) rows.push({ label: 'Session cost (estimate)', value: cost, hint: 'Client-side estimate, not a billing statement' });
-    const apiDuration = formatDuration(session.totalApiDurationMs);
-    if (apiDuration) rows.push({ label: 'API time', value: apiDuration });
-    const wallDuration = formatDuration(session.totalDurationMs);
-    if (wallDuration) rows.push({ label: 'Wall-clock time', value: wallDuration });
-    if (session.totalLinesAdded !== null) rows.push({ label: 'Lines added', value: String(session.totalLinesAdded) });
-    if (session.totalLinesRemoved !== null) rows.push({ label: 'Lines removed', value: String(session.totalLinesRemoved) });
-    const sessionSection = buildDetailSection({ id: 'claude-session', label: 'Latest session totals', rows });
-    if (sessionSection) details.push(sessionSection);
-
-    const modelRows = (session.modelUsage || []).map((entry) => ({
-      label: entry.model,
-      value: formatUsd(entry.costUsd) ?? '—',
-      hint: [
-        formatTokens(entry.inputTokens) ? `in ${formatTokens(entry.inputTokens)}` : null,
-        formatTokens(entry.outputTokens) ? `out ${formatTokens(entry.outputTokens)}` : null,
-        formatTokens(entry.cacheReadTokens) ? `cache r ${formatTokens(entry.cacheReadTokens)}` : null,
-        formatTokens(entry.cacheWriteTokens) ? `cache w ${formatTokens(entry.cacheWriteTokens)}` : null,
-      ].filter(Boolean).join(' · ') || null,
+  if (hasLive && live.breakdown.length) {
+    details.push(buildDetailSection({
+      id: 'claude-week-by-product',
+      label: 'This week by product',
+      note: 'Share of this week’s usage per product, as claude.ai reports it. Cloud sessions count under Claude Code.',
+      rows: live.breakdown.map((row) => ({ label: row.name, value: `${Math.round(row.percent * 10) / 10}%` })),
     }));
-    const modelSection = buildDetailSection({ id: 'claude-models', label: 'By model (session)', rows: modelRows });
-    if (modelSection) details.push(modelSection);
   }
+  const prepaid = normalizeClaudePrepaidCredits(account?.prepaid);
+  if (prepaid && prepaid.amount !== 0) {
+    details.push(buildDetailSection({
+      id: 'claude-credits',
+      label: 'Credits',
+      rows: [{ label: 'Prepaid credits', value: formatClaudeMoney(prepaid.amount, prepaid.currency), hint: 'Balance of the organisation' }],
+    }));
+  }
+  details.push(...buildClaudeSessionSections(usage?.session));
+  details.push(...behaviorSections(usage?.behaviors));
 
-  details.push(...behaviorSections(usage.behaviors).filter(Boolean));
+  const notes = [];
+  if (hasLive) {
+    // The claude.ai usage page also lists limit-reset vouchers; no endpoint
+    // the CLI login reaches has a field for them.
+    notes.push({
+      id: 'claude-limit-resets',
+      text: 'Limit resets (full / 5-hour) are shown on claude.ai only.',
+      link: { label: 'Open the usage page', url: CLAUDE_USAGE_URL },
+    });
+  } else if (toTrimmedString(account?.error)) {
+    notes.push({
+      id: 'claude-live-unavailable',
+      text: `Live account usage could not be read, so this is the reading of the last Claude turn. ${toTrimmedString(account.error)}`,
+    });
+  }
 
   const resolvedMeters = meters.filter(Boolean);
   const planLimitsMissing = !resolvedMeters.length;
+  const subscriptionType = toTrimmedString(usage?.subscriptionType);
   return buildProviderCard({
     provider: CLAUDE_PROVIDER_ID,
     label: CLAUDE_LABEL,
     status: planLimitsMissing ? STATUS_PARTIAL : STATUS_OK,
-    planName: usage.subscriptionType
-      ? `${usage.subscriptionType.charAt(0).toUpperCase()}${usage.subscriptionType.slice(1)}`
+    planName: subscriptionType
+      ? `${subscriptionType.charAt(0).toUpperCase()}${subscriptionType.slice(1)}`
       : null,
     message: planLimitsMissing
-      ? (usage.rateLimitsAvailable
+      ? (hasLive || usage?.rateLimitsAvailable
         ? 'Plan rate limits were not reported for this session.'
         : 'This session authenticates without claude.ai plan limits (API key or third-party provider), so only session cost is available.')
       : null,
-    source: stale ? SOURCE_CACHE : SOURCE_WORKER,
-    stale,
-    capturedAt,
+    source: hasLive ? SOURCE_LIVE : (stale ? SOURCE_CACHE : SOURCE_WORKER),
+    stale: hasLive ? false : stale,
+    capturedAt: hasLive ? (toIsoTimestamp(account?.fetchedAt) || capturedAt) : capturedAt,
     meters: resolvedMeters,
-    details,
+    details: details.filter(Boolean),
+    notes,
     links: [{ label: 'Claude usage settings', url: CLAUDE_USAGE_URL }],
   });
 }