tledger 0.3.0 → 0.4.0

package/bin/token-ledger-trend-terminal.mjs

@@ -1,9 +1,30 @@
 import { buildBurnDayBins, buildUsageTrend, trendModelLabel } from "./token-ledger-trend.mjs";
+import { chooseBinSize } from "./token-ledger-image-layout.mjs";
 import {
+  MAX_SAFE_TOKEN_COUNT,
+  checkedTokenAdd,
   splitUsageBucketsAtBoundaries,
+  tokenValue,
   usageBuckets,
   usageCallCount,
 } from "../lib/token-ledger-usage.mjs";
+import {
+  createTimeZoneFormatter,
+  formatCalendarDate,
+  localDateBoundary,
+  localDateString,
+  shiftCalendarDate,
+} from "../lib/token-ledger-calendar.mjs";
+import { isFastServiceTier } from "../lib/token-ledger-rates.mjs";
+import { sanitizeTerminalText } from "../lib/token-ledger-terminal-text.mjs";
+import {
+  snapshotFreshnessDetail,
+  sourceStatusLine,
+} from "./token-ledger-source-status.mjs";
+import { incompleteSourceWarning } from "./token-ledger-terminal.mjs";
+
+export { chooseBinSize } from "./token-ledger-image-layout.mjs";
+import { historyScopeLabel } from "../lib/token-ledger-collection.mjs";
 
 const RESET = "\u001b[0m";
 const PRIMARY_STYLE = [38, 2, 255, 255, 255];
@@ -12,9 +33,97 @@ const BORDER_STYLE = [38, 2, 88, 88, 88];
 const GRID_STYLE = [38, 2, 72, 72, 72];
 const LINE_STYLE = [1, 38, 2, 255, 236, 168];
 const RESET_LINE_STYLE = [1, 38, 2, 255, 255, 255];
+const TOKEN_SCALE = Symbol("tokenScale");
+
+function tokenScale(target) {
+  return Number.isFinite(target[TOKEN_SCALE]) && target[TOKEN_SCALE] >= 1
+    ? target[TOKEN_SCALE]
+    : 1;
+}
+
+function setTokenScale(target, scale) {
+  Object.defineProperty(target, TOKEN_SCALE, {
+    configurable: true,
+    enumerable: false,
+    value: scale,
+    writable: true,
+  });
+}
+
+function scaleTokenMap(values, ratio) {
+  for (const [model, value] of values) {
+    values.set(model, value * ratio);
+  }
+}
+
+function addBinTokens(bin, model, tokens, fast) {
+  if (!(tokens > 0)) return;
+  const scale = tokenScale(bin);
+  const scaledTokens = tokens / scale;
+  bin.totalTokens += scaledTokens;
+  bin.values.set(model, (bin.values.get(model) ?? 0) + scaledTokens);
+  if (fast) {
+    bin.fastValues.set(model, (bin.fastValues.get(model) ?? 0) + scaledTokens);
+  }
+
+  const scaleFactor = Math.max(1, bin.totalTokens / MAX_SAFE_TOKEN_COUNT);
+  if (scaleFactor === 1) return;
+  bin.totalTokens = MAX_SAFE_TOKEN_COUNT;
+  scaleTokenMap(bin.values, 1 / scaleFactor);
+  scaleTokenMap(bin.fastValues, 1 / scaleFactor);
+  setTokenScale(bin, scale * scaleFactor);
+}
+
+function mergeBinTotals(state, bin) {
+  const sourceScale = tokenScale(bin);
+  const commonScale = Math.max(state.scale, sourceScale);
+  const targetRatio = state.scale / commonScale;
+  const sourceRatio = sourceScale / commonScale;
+  state.totalTokens *= targetRatio;
+  scaleTokenMap(state.values, targetRatio);
+  scaleTokenMap(state.fastValues, targetRatio);
+  for (const [model, value] of bin.values) {
+    state.totalTokens += value * sourceRatio;
+    state.values.set(
+      model,
+      (state.values.get(model) ?? 0) + value * sourceRatio,
+    );
+  }
+  for (const [model, value] of bin.fastValues) {
+    state.fastValues.set(
+      model,
+      (state.fastValues.get(model) ?? 0) + value * sourceRatio,
+    );
+  }
+  if (bin.estimated) state.estimated = true;
+  for (const model of bin.estimatedModels) {
+    state.estimatedModels.add(model);
+  }
+
+  const scaleFactor = Math.max(1, state.totalTokens / MAX_SAFE_TOKEN_COUNT);
+  if (scaleFactor > 1) {
+    state.totalTokens = MAX_SAFE_TOKEN_COUNT;
+    scaleTokenMap(state.values, 1 / scaleFactor);
+    scaleTokenMap(state.fastValues, 1 / scaleFactor);
+  }
+  state.scale = commonScale * scaleFactor;
+}
+
+function alignBinsToScale(bins, scale) {
+  for (const bin of bins) {
+    const sourceScale = tokenScale(bin);
+    if (sourceScale === scale) continue;
+    const ratio = sourceScale / scale;
+    bin.totalTokens *= ratio;
+    scaleTokenMap(bin.values, ratio);
+    scaleTokenMap(bin.fastValues, ratio);
+    setTokenScale(bin, scale);
+  }
+}
 
 // Mirrors the SVG renderer's validated categorical palette.
 export const TREND_MODEL_COLORS = {
+  Astra: [38, 2, 232, 121, 249],
   Luna: [38, 2, 42, 120, 214],
   Sol: [38, 2, 235, 104, 52],
   Terra: [38, 2, 27, 175, 122],
@@ -28,6 +137,7 @@ export const TREND_MODEL_COLORS = {
 };
 
 const MODEL_ORDER = [
+  "Astra",
   "Luna",
   "Sol",
   "Terra",
@@ -39,6 +149,8 @@ const MODEL_ORDER = [
   "Unknown",
 ];
 
+const ATTRIBUTION_MODEL_ORDER = ["Astra", "Luna", "Sol", "Terra"];
+
 function colorsEnabled(options = {}) {
   return options.forceColor ??
     (!options.plain && !process.env.NO_COLOR && Boolean(process.stdout.isTTY));
@@ -49,7 +161,7 @@ function colorize(value, style, enabled) {
 }
 
 function stripAnsi(value) {
-  return String(value).replace(/\u001b\[[0-9;]*m/g, "");
+  return sanitizeTerminalText(value);
 }
 
 function visibleLength(value) {
@@ -112,101 +224,11 @@ function modelSort(left, right) {
   );
 }
 
-function dateParts(dateString) {
-  return dateString.split("-").map(Number);
-}
-
-function dateStringFromParts(year, month, day) {
-  return [year, month, day]
-    .map((value, index) =>
-      index === 0 ? String(value) : String(value).padStart(2, "0"),
-    )
-    .join("-");
-}
-
-function shiftCalendarDate(dateString, amount) {
-  const [year, month, day] = dateParts(dateString);
-  const date = new Date(Date.UTC(year, month - 1, day + amount));
-  return dateStringFromParts(
-    date.getUTCFullYear(),
-    date.getUTCMonth() + 1,
-    date.getUTCDate(),
-  );
-}
-
-function timeZoneFormatter(timeZone) {
-  return new Intl.DateTimeFormat("en-US", {
-    timeZone,
-    timeZoneName: "longOffset",
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hourCycle: "h23",
-  });
-}
-
-function timeZoneOffsetMs(instant, formatter) {
-  const parts = formatter.formatToParts(instant);
-  const value = parts.find((part) => part.type === "timeZoneName")?.value ?? "GMT";
-  if (value === "GMT") return 0;
-  const match = value.match(/^GMT([+-])(\d{2}):?(\d{2})?$/);
-  if (!match) return 0;
-  const minutes = Number(match[2]) * 60 + Number(match[3] || 0);
-  return (match[1] === "+" ? 1 : -1) * minutes * 60 * 1_000;
-}
-
-function zonedMidnight(
-  dateString,
-  timeZone,
-  formatter = timeZoneFormatter(timeZone),
-) {
-  const [year, month, day] = dateParts(dateString);
-  const utcGuess = Date.UTC(year, month - 1, day);
-  const first = new Date(utcGuess - timeZoneOffsetMs(new Date(utcGuess), formatter));
-  return new Date(first.getTime() - timeZoneOffsetMs(first, formatter));
-}
-
-function localDateString(
-  timestamp,
-  timeZone,
-  formatter = timeZoneFormatter(timeZone),
-) {
-  const parts = formatter.formatToParts(new Date(timestamp));
-  const values = Object.fromEntries(
-    parts
-      .filter((part) => part.type !== "literal")
-      .map((part) => [part.type, part.value]),
-  );
-  return `${values.year}-${values.month}-${values.day}`;
-}
-
-function localDateLabel(dateString, timeZone) {
-  const date = zonedMidnight(dateString, timeZone);
-  return new Intl.DateTimeFormat("en-US", {
-    timeZone,
+function localDateLabel(dateString) {
+  return formatCalendarDate(dateString, {
     month: "short",
     day: "2-digit",
-  })
-    .format(date)
-    .toUpperCase();
-}
-
-export function chooseBinSize(days, width, { minBinWidth = 1, preferDaily = false } = {}) {
-  const rangeDays = Number(days);
-  const plotWidth = Math.max(1, Number(width) || 1);
-  const minimumBinWidth = Math.max(1, Number(minBinWidth) || 1);
-  const maxBinCount = Math.max(1, Math.floor(plotWidth / minimumBinWidth));
-  const preferredBinSize = preferDaily
-    ? 1
-    : rangeDays <= 14
-      ? 1
-      : plotWidth >= 120
-        ? 2
-        : 3;
-  return Math.max(preferredBinSize, Math.ceil(rangeDays / maxBinCount));
+  }).toUpperCase();
 }
 
 function sortedModelEntries(values) {
@@ -220,7 +242,12 @@ export function buildActualTokenBins(
   bounds,
   days,
   width,
-  { binSize: forcedBinSize, minBinWidth, preferDaily } = {},
+  {
+    binSize: forcedBinSize,
+    minBinWidth,
+    preferDaily,
+    events = null,
+  } = {},
 ) {
   const binSize = forcedBinSize ?? chooseBinSize(days, width, { minBinWidth, preferDaily });
   const binCount = Math.ceil(days / binSize);
@@ -234,6 +261,8 @@ export function buildActualTokenBins(
     fastValues: new Map(),
     totalTokens: 0,
     calls: 0,
+    estimated: false,
+    estimatedModels: new Set(),
   }));
   const startDate = bounds.startDateString;
   const dateIndexByString = new Map(
@@ -242,16 +271,16 @@ export function buildActualTokenBins(
       index,
     ]),
   );
-  const dateFormatter = timeZoneFormatter(bounds.timeZone);
+  const dateFormatter = createTimeZoneFormatter(bounds.timeZone);
   const binBoundaries = [
     bins[0]?.startDateString,
     ...bins.map((bin) => bin.endDateString),
   ]
     .filter(Boolean)
     .map((dateString) =>
-      zonedMidnight(dateString, bounds.timeZone, dateFormatter).getTime());
+      localDateBoundary(dateString, bounds.timeZone, dateFormatter).getTime());
   for (const event of splitUsageBucketsAtBoundaries(
-    usageBuckets(snapshot),
+    events ?? usageBuckets(snapshot),
     binBoundaries,
   )) {
     const timestamp = new Date(event.timestamp).getTime();
@@ -260,27 +289,42 @@ export function buildActualTokenBins(
     const dayIndex = dateIndexByString.get(dateString);
     if (dayIndex === undefined || dayIndex >= days) continue;
     const bin = bins[Math.floor(dayIndex / binSize)];
-    const tokens = Math.max(0, Number(event.totalTokens) || 0);
+    if (event?.invalidTokenRecord === true) continue;
+    const allowFractional = event.rangeAllocationEstimated === true;
+    const tokens = tokenValue(event.totalTokens, { allowFractional });
     const model = trendModelLabel(event.model);
-    bin.totalTokens += tokens;
-    bin.calls += usageCallCount(event);
-    bin.values.set(model, (bin.values.get(model) ?? 0) + tokens);
-    if (event.serviceTier === "priority") {
-      bin.fastValues.set(model, (bin.fastValues.get(model) ?? 0) + tokens);
+    if (event.rangeAllocationEstimated === true && tokens > 0) {
+      bin.estimated = true;
+      bin.estimatedModels.add(model);
     }
+    bin.calls = checkedTokenAdd(bin.calls, usageCallCount(event), {
+      allowFractional,
+    });
+    addBinTokens(bin, model, tokens, isFastServiceTier(event.serviceTier));
   }
 
-  const totals = new Map();
-  const fastTotals = new Map();
+  const totalsState = {
+    scale: 1,
+    totalTokens: 0,
+    values: new Map(),
+    fastValues: new Map(),
+    estimated: false,
+    estimatedModels: new Set(),
+  };
   for (const bin of bins) {
-    for (const [model, value] of bin.values) {
-      totals.set(model, (totals.get(model) ?? 0) + value);
-    }
-    for (const [model, value] of bin.fastValues) {
-      fastTotals.set(model, (fastTotals.get(model) ?? 0) + value);
-    }
+    mergeBinTotals(totalsState, bin);
   }
-  return { bins, totals, fastTotals, binSize, binCount };
+  alignBinsToScale(bins, totalsState.scale);
+  return {
+    bins,
+    totals: totalsState.values,
+    fastTotals: totalsState.fastValues,
+    estimated: totalsState.estimated,
+    estimatedModels: totalsState.estimatedModels,
+    scale: totalsState.scale,
+    binSize,
+    binCount,
+  };
 }
 
 function niceCeiling(value) {
@@ -296,7 +340,12 @@ function allocateSegmentHeights(entries, total, maxValue, plotHeight) {
     ? Math.max(1, Math.round((total / maxValue) * (plotHeight - 1)))
     : 0;
   if (!barHeight) return [];
-  const ideal = entries.map(([, value]) => (value / total) * barHeight);
+  // Model counters can cap independently when the bin total reaches the
+  // safe-token limit. Partition the already-scaled bar across the model
+  // entries so capped components cannot make the stack taller than its bin.
+  const segmentTotal = entries.reduce((sum, [, value]) => sum + value, 0);
+  const partitionTotal = segmentTotal > 0 ? segmentTotal : total;
+  const ideal = entries.map(([, value]) => (value / partitionTotal) * barHeight);
   const heights = ideal.map(Math.floor);
   let remainder = barHeight - heights.reduce((sum, value) => sum + value, 0);
   const order = ideal
@@ -319,11 +368,17 @@ function allocateSegmentHeights(entries, total, maxValue, plotHeight) {
   return heights;
 }
 
-function sampleQuota(trend, bounds, width) {
+export function sampleQuota(trend, bounds, width) {
   const startMs = bounds.start.getTime();
   const endMs = bounds.end.getTime();
   const points = trend.points ?? [];
   const resets = trend.resets ?? [];
+  const lastObservedPoint = [...points]
+    .reverse()
+    .find((point) => point.observed !== false);
+  const observedThroughMs = Number.isFinite(trend.observedThroughMs)
+    ? Math.min(endMs, trend.observedThroughMs)
+    : lastObservedPoint?.timestampMs ?? null;
   const samples = [];
   let pointIndex = 0;
   let resetIndex = 0;
@@ -332,6 +387,18 @@ function sampleQuota(trend, bounds, width) {
   for (let column = 0; column < width; column += 1) {
     const ratio = width <= 1 ? 0 : column / (width - 1);
     const timestampMs = startMs + (endMs - startMs) * ratio;
+    if (
+      observedThroughMs === null ||
+      timestampMs > observedThroughMs
+    ) {
+      samples.push({
+        timestampMs,
+        point: null,
+        reset: false,
+        remainingPercent: null,
+      });
+      continue;
+    }
     while (
       pointIndex < points.length &&
       points[pointIndex].timestampMs <= timestampMs
@@ -376,7 +443,7 @@ function lineRow(remainingPercent, plotHeight) {
   );
 }
 
-function xLabelLine(bins, plotWidth, leftWidth, rightWidth, timeZone) {
+function xLabelLine(bins, plotWidth, leftWidth, rightWidth) {
   const labels = Array.from({ length: plotWidth }, () => " ");
   const write = (label, offset) => {
     for (let index = 0; index < label.length; index += 1) {
@@ -387,7 +454,7 @@ function xLabelLine(bins, plotWidth, leftWidth, rightWidth, timeZone) {
   bins.forEach((bin, index) => {
     const start = Math.round((index * plotWidth) / bins.length);
     const end = Math.round(((index + 1) * plotWidth) / bins.length);
-    const label = localDateLabel(bin.startDateString, timeZone);
+    const label = localDateLabel(bin.startDateString);
     if (end - start >= label.length) {
       write(label, start + Math.floor((end - start - label.length) / 2));
     } else if (index === 0 || index === bins.length - 1 || end - start >= 4) {
@@ -406,9 +473,26 @@ function frameLine(content, width) {
   return `│${fit(content, width - 2)}│`;
 }
 
+function wrapAttributionEntries(prefix, entries, width) {
+  const lines = [];
+  let line = prefix;
+  for (const entry of entries) {
+    const separator = line === prefix ? " · " : "   ";
+    const candidate = `${line}${separator}${entry}`;
+    if (visibleLength(candidate) <= width) {
+      line = candidate;
+      continue;
+    }
+    lines.push(line);
+    line = entry;
+  }
+  lines.push(line);
+  return lines;
+}
+
 function formatAttribution(trend, enabled, width, percentMode) {
   const rows = new Map((trend.models ?? []).map((row) => [row.model, row]));
-  const entries = ["Luna", "Sol"]
+  const entries = ATTRIBUTION_MODEL_ORDER
     .map((model) => {
       const row = rows.get(model);
       if (!row || !(row.tokensPerBurnPoint > 0)) return null;
@@ -418,30 +502,20 @@ function formatAttribution(trend, enabled, width, percentMode) {
     })
     .filter(Boolean);
   if (!entries.length) return [];
-  if (percentMode) {
-    const valueLine = colorize(
-      `Observed burn rate · ${entries.join("   ")}`,
-      SECONDARY_STYLE,
-      enabled,
-    );
-    const method = colorize(
-      `Columns sum to observed meter drops; model split via rate-card credit weights (card ${trend.rateCardAsOf}).`,
-      SECONDARY_STYLE,
-      enabled,
-    );
-    return [fit(valueLine, width - 2), fit(method, width - 2)];
-  }
-  const valueLine = colorize(
-    `ESTIMATE ONLY · quota attribution lens · ${entries.join("   ")}`,
-    SECONDARY_STYLE,
-    enabled,
+  const prefix = percentMode
+    ? "Observed burn rate"
+    : "ESTIMATE ONLY · quota attribution lens";
+  const valueLines = wrapAttributionEntries(prefix, entries, width - 2).map(
+    (line) => fit(colorize(line, SECONDARY_STYLE, enabled), width - 2),
   );
   const method = colorize(
-    `Rate-card/token weights, ${trend.rateCardAsOf}; separate from actual-token bars and not official quota math.`,
+    percentMode
+      ? `Columns sum to observed meter drops; model split via rate-card credit weights (card ${trend.rateCardAsOf}).`
+      : `Rate-card/token weights, ${trend.rateCardAsOf}; separate from actual-token bars and not official quota math.`,
     SECONDARY_STYLE,
     enabled,
   );
-  return [fit(valueLine, width - 2), fit(method, width - 2)];
+  return [...valueLines, fit(method, width - 2)];
 }
 
 function drainLabelLine(burnBins, plotWidth, leftWidth, rightWidth, enabled) {
@@ -467,10 +541,14 @@ function drainLabelLine(burnBins, plotWidth, leftWidth, rightWidth, enabled) {
 export function renderTrendCombo({
   snapshot,
   bounds,
-  trend = buildUsageTrend(snapshot, bounds),
+  trend: providedTrend = null,
   days = bounds.rangeDays ?? 7,
   options = {},
+  analysis = null,
+  snapshotFreshness = null,
+  sourceStatus = "unchecked-cache",
 }) {
+  const trend = providedTrend ?? analysis?.trend ?? buildUsageTrend(snapshot, bounds, { analysis });
   const enabled = colorsEnabled(options);
   const frameWidth = Math.max(82, Math.min(158, Number(options.width) || 120));
   const innerWidth = frameWidth - 2;
@@ -478,7 +556,9 @@ export function renderTrendCombo({
   const rightWidth = 7;
   const plotWidth = Math.max(36, innerWidth - leftWidth - rightWidth - 2);
   const plotHeight = 11;
-  const actual = buildActualTokenBins(snapshot, bounds, days, plotWidth);
+  const actual = buildActualTokenBins(snapshot, bounds, days, plotWidth, {
+    events: analysis?.currentEvents,
+  });
   const burn = buildBurnDayBins(trend, bounds, {
     days,
     binSize: actual.binSize,
@@ -488,6 +568,9 @@ export function renderTrendCombo({
   // and shows the observed drop per column in a label row instead.
   const meterUsable = Boolean(trend.available && burn.totalPercent > 0);
   const percentMode = Boolean(options.drain) && meterUsable;
+  const meterAvailable = Boolean(trend.available && (trend.points ?? []).length > 0);
+  const drainFallback = Boolean(options.drain) && !percentMode;
+  const actualEstimated = actual.estimated === true;
   const barBins = percentMode ? burn.bins : actual.bins;
   const binTotal = (bin) => (percentMode ? bin.totalPercent : bin.totalTokens);
   const maxLeft = niceCeiling(
@@ -561,11 +644,23 @@ export function renderTrendCombo({
   }
 
   const axisRows = [0, Math.floor(baseline / 2), baseline];
+  const history = historyScopeLabel(snapshot);
+  const sourceWarning = incompleteSourceWarning(snapshot);
+  const actualModeTitle = drainFallback
+    ? "ACTUAL TOKENS · DRAIN UNAVAILABLE"
+    : meterAvailable
+      ? "ACTUAL TOKENS + WEEKLY QUOTA"
+      : "ACTUAL TOKENS";
+  const actualModeSubtitle = drainFallback
+    ? `DRAIN UNAVAILABLE · BARS = raw local tokens${actualEstimated ? " · ≈ marks allocated estimates" : ""}${meterAvailable ? " · LINE = meter remaining" : ""}`
+    : meterAvailable
+      ? `BARS = ${actualEstimated ? "token quantity by model · ≈ marks allocated estimates" : "actual token quantity by model"} · LINE = meter remaining${meterUsable ? " · -% row = observed drain per column" : " · no usable meter drain observed"}`
+      : `BARS = ${actualEstimated ? "token quantity by model · ≈ marks allocated estimates" : "actual token quantity by model"} · no account-wide weekly meter observed`;
   const lines = [
     `┌${"─".repeat(frameWidth - 2)}┐`,
     frameLine(
       colorize(
-        `TOKEN LEDGER · ${percentMode ? "OBSERVED LIMIT DRAIN + WEEKLY METER" : "ACTUAL TOKENS + WEEKLY QUOTA"} · ${localDateLabel(bounds.startDateString, bounds.timeZone)} – ${localDateLabel(bounds.endDateString, bounds.timeZone)} · ${days}D`,
+        `TOKEN LEDGER · ${percentMode ? "OBSERVED LIMIT DRAIN + WEEKLY METER" : actualModeTitle} · ${localDateLabel(bounds.startDateString)} – ${localDateLabel(bounds.endDateString)} · ${days}D`,
         PRIMARY_STYLE,
         enabled,
       ),
@@ -575,14 +670,30 @@ export function renderTrendCombo({
       colorize(
         percentMode
           ? "BARS = observed limit % consumed per day by model · LINE = meter remaining · one percent scale"
-          : meterUsable
-            ? "BARS = actual token quantity by model · LINE = meter remaining · -% row = observed drain per column"
-            : "BARS = actual token quantity by model · LINE = observed remaining quota · separate scales",
+          : actualModeSubtitle,
+        SECONDARY_STYLE,
+        enabled,
+      ),
+      frameWidth,
+    ),
+    frameLine(
+      colorize(
+        `SNAPSHOT · ${snapshotFreshnessDetail(snapshotFreshness)}`,
         SECONDARY_STYLE,
         enabled,
       ),
       frameWidth,
     ),
+    frameLine(
+      colorize(sourceStatusLine(sourceStatus), SECONDARY_STYLE, enabled),
+      frameWidth,
+    ),
+    ...(history
+      ? [frameLine(colorize(history, SECONDARY_STYLE, enabled), frameWidth)]
+      : []),
+    ...(sourceWarning
+      ? [frameLine(colorize(sourceWarning, SECONDARY_STYLE, enabled), frameWidth)]
+      : []),
     `├${"─".repeat(frameWidth - 2)}┤`,
   ];
   for (let row = 0; row < plotHeight; row += 1) {
@@ -593,7 +704,9 @@ export function renderTrendCombo({
         ? percent(leftValue)
         : compact(leftValue)
       : "";
-    const rightLabel = axisRows.includes(row) ? `${Math.round(rightValue)}%` : "";
+    const rightLabel = meterAvailable && axisRows.includes(row)
+      ? `${Math.round(rightValue)}%`
+      : "";
     const content = chart[row]
       .map(({ char, style }) => colorize(char, style, enabled))
       .join("");
@@ -601,16 +714,21 @@ export function renderTrendCombo({
   }
   const axis = `${" ".repeat(leftWidth)}${colorize(`└${"─".repeat(plotWidth)}┘`, BORDER_STYLE, enabled)}${" ".repeat(rightWidth)}`;
   lines.push(frameLine(axis, frameWidth));
-  lines.push(frameLine(xLabelLine(barBins, plotWidth, leftWidth, rightWidth, bounds.timeZone), frameWidth));
+  lines.push(frameLine(xLabelLine(barBins, plotWidth, leftWidth, rightWidth), frameWidth));
   if (!percentMode && meterUsable) {
     lines.push(frameLine(drainLabelLine(burn.bins, plotWidth, leftWidth, rightWidth, enabled), frameWidth));
     lines.push(frameLine(fit("CALENDAR DAY · -% = OBSERVED METER DROP", innerWidth, "center"), frameWidth));
+  } else if (drainFallback) {
+    lines.push(frameLine(fit("CALENDAR DAY · --drain unavailable; showing raw local tokens", innerWidth, "center"), frameWidth));
   } else {
     lines.push(frameLine(fit("CALENDAR DAY", innerWidth, "center"), frameWidth));
   }
   lines.push(`├${"─".repeat(frameWidth - 2)}┤`);
 
-  const totalTokens = [...actual.totals.values()].reduce((sum, value) => sum + value, 0);
+  const totalTokens = [...actual.totals.values()].reduce(
+    (sum, value) => checkedTokenAdd(sum, value, { allowFractional: true }),
+    0,
+  );
   const legendModels = percentMode
     ? [...burn.totals.keys()].sort(modelSort)
     : [...actual.totals.keys()].sort(modelSort);
@@ -628,20 +746,25 @@ export function renderTrendCombo({
     const fastPart = fastTokens > 0
       ? ` · ${percent((fastTokens / actual.totals.get(model)) * 100)} fast`
       : "";
+    const estimatedPrefix = actual.estimatedModels?.has(model) ? "≈" : "";
     return colorize(
-      `■ ${model} ${compact(actual.totals.get(model))} (${percent((actual.totals.get(model) / totalTokens) * 100)})${fastPart}`,
+      `■ ${model} ${estimatedPrefix}${compact(actual.totals.get(model))} (${percent((actual.totals.get(model) / totalTokens) * 100)})${fastPart}`,
       styleForModel(model),
       enabled,
     );
   });
-  lines.push(frameLine(colorize(percentMode ? "OBSERVED LIMIT DRAIN BY MODEL · LEFT AXIS" : "ACTUAL TOKEN VOLUME · LEFT AXIS", PRIMARY_STYLE, enabled), frameWidth));
+  lines.push(frameLine(colorize(percentMode ? "OBSERVED LIMIT DRAIN BY MODEL · LEFT AXIS" : actualEstimated ? "ACTUAL TOKEN VOLUME BY MODEL · ≈ = ALLOCATED ESTIMATE · LEFT AXIS" : "ACTUAL TOKEN VOLUME · LEFT AXIS", PRIMARY_STYLE, enabled), frameWidth));
   for (let index = 0; index < legend.length; index += 2) {
     const leftLegendWidth = Math.floor((innerWidth - 2) / 2);
     const rightLegendWidth = innerWidth - 2 - leftLegendWidth;
     lines.push(frameLine(`${fit(legend[index], leftLegendWidth)}  ${fit(legend[index + 1] ?? "", rightLegendWidth)}`, frameWidth));
   }
-  lines.push(frameLine(colorize("LINE · OBSERVED WEEKLY QUOTA REMAINING · RIGHT AXIS", LINE_STYLE, enabled), frameWidth));
-  lines.push(frameLine(colorize("↟ reset marker returns the line to 100%; it never rises within a cycle", SECONDARY_STYLE, enabled), frameWidth));
+  if (meterAvailable) {
+    lines.push(frameLine(colorize("LINE · OBSERVED WEEKLY QUOTA REMAINING · RIGHT AXIS", LINE_STYLE, enabled), frameWidth));
+    lines.push(frameLine(colorize("↟ reset marker returns the line to 100%; it never rises within a cycle", SECONDARY_STYLE, enabled), frameWidth));
+  } else {
+    lines.push(frameLine(colorize("NO ACCOUNT-WIDE WEEKLY METER OBSERVED", SECONDARY_STYLE, enabled), frameWidth));
+  }
   for (const line of formatAttribution(trend, enabled, frameWidth, percentMode)) {
     lines.push(frameLine(line, frameWidth));
   }