vibestats 1.3.11 → 1.3.13

package/dist/index.js

@@ -848,9 +848,9 @@ function buildActivityGraph(stats, metric, requestedDays = 365) {
   };
 }
 function buildActivityTitle(stats, metric) {
-  const sourceLabel = stats.scopeLabel ? stats.scopeLabel : stats.source === "codex" ? "Codex" : stats.source === "combined" ? "AI Coding" : "Local AI";
+  const sourceLabel2 = stats.scopeLabel ? stats.scopeLabel : stats.source === "codex" ? "Codex" : stats.source === "combined" ? "AI Coding" : "Local AI";
   const metricLabel = metric === "tokens" ? "Activity" : metric === "sessions" ? "Session Activity" : "Message Activity";
-  return `${sourceLabel} ${metricLabel}`;
+  return `${sourceLabel2} ${metricLabel}`;
 }
 function buildActivityArtifactPayload(stats, metric, requestedDays = 365) {
   return {
@@ -2199,9 +2199,9 @@ function renderBreakdownLines(items, options = {}) {
   return items.map((item) => {
     const filled = clamp(Math.round(item.percentage / 100 * width), 0, width);
     const empty = Math.max(0, width - filled);
-    const bar = `${filledColor}${"\u2588".repeat(filled)}${emptyColor}${"\u2591".repeat(empty)}${reset}`;
+    const bar2 = `${filledColor}${"\u2588".repeat(filled)}${emptyColor}${"\u2591".repeat(empty)}${reset}`;
     const suffix = item.valueLabel ? ` ${item.valueLabel}` : "";
-    return `${item.label.padEnd(labelWidth)} ${bar} ${item.percentage}%${suffix}`;
+    return `${item.label.padEnd(labelWidth)} ${bar2} ${item.percentage}%${suffix}`;
   });
 }
 
@@ -3204,6 +3204,1091 @@ async function inspectClaudeUsage(claudeDir = getClaudeDir2()) {
   };
 }
 
+// src/cli-intent.ts
+var COMMANDS = /* @__PURE__ */ new Set(["usage", "limits", "limit", "pace"]);
+var SCOPES = /* @__PURE__ */ new Set(["claude", "codex", "all", "combined"]);
+var USAGE_COMMAND_FLAGS = /* @__PURE__ */ new Set([
+  "activity",
+  "compact",
+  "daily",
+  "days",
+  "last",
+  "metric",
+  "model",
+  "monthly",
+  "project",
+  "sessions",
+  "share",
+  "since",
+  "total",
+  "until",
+  "wrapped"
+]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "activity",
+  "claude",
+  "claude-limits",
+  "claude-system",
+  "codex",
+  "combined",
+  "compact",
+  "config",
+  "daily",
+  "init",
+  "json",
+  "kimi",
+  "limits",
+  "minimax",
+  "model",
+  "monthly",
+  "no-short",
+  "project",
+  "quiet",
+  "sessions",
+  "share",
+  "total",
+  "wrapped"
+]);
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["days", "last", "metric", "since", "until", "url"]);
+var SHORT_BOOLEAN_FLAGS = {
+  c: "compact",
+  d: "daily",
+  m: "monthly",
+  p: "project",
+  q: "quiet",
+  s: "share",
+  t: "total",
+  w: "wrapped"
+};
+var SHORT_VALUE_FLAGS = {
+  l: "last"
+};
+function parseRawFlags(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (!arg?.startsWith("-")) continue;
+    if (arg.startsWith("--")) {
+      const raw = arg.slice(2);
+      const [key, inlineValue] = raw.split("=", 2);
+      if (!key) continue;
+      if (/^last\d+$/.test(key)) {
+        parsed[key] = true;
+      } else if (BOOLEAN_FLAGS.has(key)) {
+        parsed[key] = true;
+      } else if (VALUE_FLAGS.has(key)) {
+        if (inlineValue !== void 0) {
+          parsed[key] = inlineValue;
+        } else {
+          const next = argv[index + 1];
+          if (next && !next.startsWith("-")) {
+            parsed[key] = next;
+            index++;
+          }
+        }
+      }
+      continue;
+    }
+    const short = arg.slice(1);
+    if (!short) continue;
+    if (SHORT_VALUE_FLAGS[short]) {
+      const next = argv[index + 1];
+      if (next && !next.startsWith("-")) {
+        parsed[SHORT_VALUE_FLAGS[short]] = next;
+        index++;
+      }
+      continue;
+    }
+    for (const char of short) {
+      const key = SHORT_BOOLEAN_FLAGS[char];
+      if (key) parsed[key] = true;
+    }
+  }
+  return parsed;
+}
+function collectPositionals(argv) {
+  const positionals = [];
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (!arg) continue;
+    if (arg.startsWith("--")) {
+      const [key] = arg.slice(2).split("=", 2);
+      if (key && VALUE_FLAGS.has(key) && !arg.includes("=")) {
+        index++;
+      }
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      const short = arg.slice(1);
+      if (SHORT_VALUE_FLAGS[short]) {
+        index++;
+      }
+      continue;
+    }
+    positionals.push(arg);
+  }
+  return positionals;
+}
+function resolveIntentError(positionals) {
+  const first = positionals[0]?.toLowerCase();
+  if (!first) return void 0;
+  if (!COMMANDS.has(first) && !SCOPES.has(first)) {
+    return { message: `Unknown command: ${positionals[0]}` };
+  }
+  for (let index = 0; index < positionals.length; index++) {
+    const token = positionals[index];
+    const lower = token.toLowerCase();
+    if (index === 0 && COMMANDS.has(lower)) continue;
+    if (SCOPES.has(lower)) continue;
+    return { message: `Unknown argument for ${first}: ${token}` };
+  }
+  return void 0;
+}
+function hasUsageCommandFlag(flags) {
+  return Object.keys(flags).some((key) => /^last\d+$/.test(key) || USAGE_COMMAND_FLAGS.has(key));
+}
+function resolveCliIntent(argv) {
+  const positionals = collectPositionals(argv);
+  const first = positionals[0]?.toLowerCase();
+  const parsedFlags = parseRawFlags(argv);
+  let command = first === "limits" || first === "limit" || first === "pace" ? "limits" : "usage";
+  const error = resolveIntentError(positionals);
+  const scopeToken = positionals.find((token, index) => {
+    const lower = token.toLowerCase();
+    if (index === 0 && COMMANDS.has(lower)) return false;
+    return SCOPES.has(lower);
+  })?.toLowerCase();
+  const sourceScope = scopeToken === "combined" ? "all" : scopeToken === "all" ? "all" : scopeToken === "codex" ? "codex" : scopeToken === "claude" ? "claude" : void 0;
+  const normalizedArgs = {
+    ...parsedFlags
+  };
+  if (first === "usage" && sourceScope && !hasUsageCommandFlag(parsedFlags)) {
+    command = "limits";
+  }
+  if (sourceScope === "codex") {
+    normalizedArgs.codex = true;
+    normalizedArgs.combined = false;
+  } else if (sourceScope === "all") {
+    normalizedArgs.codex = false;
+    normalizedArgs.combined = true;
+  } else if (sourceScope === "claude") {
+    normalizedArgs.codex = false;
+    normalizedArgs.combined = false;
+  }
+  if (command === "limits") {
+    normalizedArgs.limits = true;
+  }
+  return { command, sourceScope, normalizedArgs, error };
+}
+function applyCliIntent(args, intent) {
+  return {
+    ...args,
+    ...intent.normalizedArgs
+  };
+}
+
+// src/limits/claude.ts
+import { execFile as execFile2 } from "child_process";
+import { randomUUID } from "crypto";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/limits/pace.ts
+var PACE_EPSILON_PERCENT = 1;
+function roundPercent(value) {
+  return Math.round(value * 100) / 100;
+}
+function clampPercent(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(100, value));
+}
+function computeLinearPace(window, now = /* @__PURE__ */ new Date()) {
+  if (!window.resetsAt || !window.windowMinutes || window.windowMinutes <= 0) {
+    return null;
+  }
+  const resetTime = new Date(window.resetsAt).getTime();
+  const nowTime = now.getTime();
+  if (!Number.isFinite(resetTime) || !Number.isFinite(nowTime)) {
+    return null;
+  }
+  const durationMs = window.windowMinutes * 60 * 1e3;
+  const remainingMs = Math.max(0, resetTime - nowTime);
+  const elapsedMs = Math.max(0, Math.min(durationMs, durationMs - remainingMs));
+  const expectedUsedPercent = durationMs === 0 ? 0 : elapsedMs / durationMs * 100;
+  const actualUsedPercent = clampPercent(window.usedPercent);
+  const deltaPercent = actualUsedPercent - expectedUsedPercent;
+  let status = "on-pace";
+  if (deltaPercent > PACE_EPSILON_PERCENT) status = "deficit";
+  else if (deltaPercent < -PACE_EPSILON_PERCENT) status = "reserve";
+  let runsOutAt;
+  let lastsUntilReset = true;
+  if (actualUsedPercent > 0 && elapsedMs > 0 && actualUsedPercent < 100) {
+    const ratePerMs = actualUsedPercent / elapsedMs;
+    const etaMs = (100 - actualUsedPercent) / ratePerMs;
+    if (etaMs < remainingMs) {
+      lastsUntilReset = false;
+      runsOutAt = new Date(nowTime + etaMs).toISOString();
+    }
+  } else if (actualUsedPercent >= 100) {
+    lastsUntilReset = false;
+    runsOutAt = now.toISOString();
+  }
+  return {
+    provider: window.provider,
+    kind: window.kind,
+    label: window.label,
+    actualUsedPercent: roundPercent(actualUsedPercent),
+    expectedUsedPercent: roundPercent(expectedUsedPercent),
+    deltaPercent: roundPercent(deltaPercent),
+    status,
+    lastsUntilReset,
+    runsOutAt,
+    source: window.source
+  };
+}
+function computeLinearPaces(windows, now = /* @__PURE__ */ new Date()) {
+  return windows.filter((window) => window.kind === "weekly" || window.kind === "model-weekly").map((window) => computeLinearPace(window, now)).filter((pace) => pace !== null);
+}
+
+// src/limits/claude.ts
+var TMUX_SESSION_PREFIX = "vibestats-claude-usage";
+var DEFAULT_TIMEOUT_MS = 2e4;
+var POLL_INTERVAL_MS = 400;
+var READY_FALLBACK_MS = 3e3;
+var USAGE_COMMAND_RETRY_MS = 2500;
+function expandTerminalCursorSpacing(text) {
+  return text.replace(/\u001B\[(\d*)C/g, (_match, count) => " ".repeat(Number.parseInt(count || "1", 10))).replace(/\u001B\[(\d*)[AB]/g, "\n").replace(/\u001B\[(\d*)D/g, "");
+}
+function stripAnsi(text) {
+  return expandTerminalCursorSpacing(text).replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+function normalizeTerminalText(text) {
+  return stripAnsi(text).replaceAll("\xA0", " ").replace(/\r/g, "\n").replace(/[ \t]+/g, " ").replace(/\n+/g, "\n").trim();
+}
+var MONTHS = {
+  jan: 1,
+  january: 1,
+  feb: 2,
+  february: 2,
+  mar: 3,
+  march: 3,
+  apr: 4,
+  april: 4,
+  may: 5,
+  jun: 6,
+  june: 6,
+  jul: 7,
+  july: 7,
+  aug: 8,
+  august: 8,
+  sep: 9,
+  sept: 9,
+  september: 9,
+  oct: 10,
+  october: 10,
+  nov: 11,
+  november: 11,
+  dec: 12,
+  december: 12
+};
+function normalizeLabel(text) {
+  return text.toLowerCase().replace(/\s+/g, "");
+}
+function clampPercent2(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(100, value));
+}
+function parseUsedPercent(line) {
+  const match = /([0-9]{1,3}(?:\.[0-9]+)?)\s*%/i.exec(line);
+  if (!match) return null;
+  const percent = clampPercent2(Number(match[1]));
+  const lower = line.toLowerCase();
+  if (lower.includes("used") || lower.includes("spent") || lower.includes("consumed")) {
+    return percent;
+  }
+  if (lower.includes("left") || lower.includes("remaining") || lower.includes("available")) {
+    return Math.max(0, Math.round((100 - percent) * 100) / 100);
+  }
+  return null;
+}
+function parseResetDescription(line) {
+  const match = /\bresets?\s+(.+)$/i.exec(line);
+  return match?.[1]?.trim() || void 0;
+}
+function remainingPercentFromUsed(usedPercent) {
+  return Math.max(0, Math.round((100 - usedPercent) * 100) / 100);
+}
+function parseTimeToken(value) {
+  const match = /^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i.exec(value.trim());
+  if (!match) return null;
+  let hour = Number(match[1]);
+  const minute = Number(match[2] || "0");
+  const meridiem = match[3]?.toLowerCase();
+  if (!Number.isFinite(hour) || !Number.isFinite(minute)) return null;
+  if (minute < 0 || minute > 59) return null;
+  if (meridiem === "pm" && hour < 12) hour += 12;
+  if (meridiem === "am" && hour === 12) hour = 0;
+  if (hour < 0 || hour > 23) return null;
+  return { hour, minute };
+}
+function localParts(date) {
+  return {
+    year: date.getFullYear(),
+    month: date.getMonth() + 1,
+    day: date.getDate(),
+    hour: date.getHours(),
+    minute: date.getMinutes()
+  };
+}
+function getZonedParts(date, timeZone) {
+  try {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      calendar: "gregory",
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+    const parts = Object.fromEntries(formatter.formatToParts(date).map((part) => [part.type, part.value]));
+    const year = Number(parts.year);
+    const month = Number(parts.month);
+    const day = Number(parts.day);
+    const hour = Number(parts.hour);
+    const minute = Number(parts.minute);
+    if ([year, month, day, hour, minute].some((value) => !Number.isFinite(value))) return null;
+    return { year, month, day, hour, minute };
+  } catch {
+    return null;
+  }
+}
+function dateInTimeZone(parts, timeZone) {
+  if (!timeZone) {
+    return new Date(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, 0, 0);
+  }
+  const utcGuess = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, 0, 0);
+  const observed = getZonedParts(new Date(utcGuess), timeZone);
+  if (!observed) return null;
+  const observedAsUtc = Date.UTC(
+    observed.year,
+    observed.month - 1,
+    observed.day,
+    observed.hour,
+    observed.minute,
+    0,
+    0
+  );
+  return new Date(utcGuess - (observedAsUtc - utcGuess));
+}
+function splitResetTimeZone(description) {
+  const match = /\s*\(([^)]+)\)\s*$/.exec(description);
+  if (!match?.[1]) return { body: description.trim() };
+  return {
+    body: description.slice(0, match.index).trim(),
+    timeZone: match[1].trim()
+  };
+}
+function addCalendarDays(parts, days) {
+  const shifted = new Date(Date.UTC(parts.year, parts.month - 1, parts.day + days, 12, 0, 0, 0));
+  return {
+    year: shifted.getUTCFullYear(),
+    month: shifted.getUTCMonth() + 1,
+    day: shifted.getUTCDate(),
+    hour: parts.hour,
+    minute: parts.minute
+  };
+}
+function parseResetDate(description, now) {
+  if (!description) return void 0;
+  const { body, timeZone } = splitResetTimeZone(description);
+  const nowParts = timeZone ? getZonedParts(now, timeZone) : localParts(now);
+  if (!nowParts) return void 0;
+  const explicitDate = /^([A-Za-z]{3,9})\s+(\d{1,2})\s+at\s+(.+)$/i.exec(body);
+  if (explicitDate?.[1] && explicitDate[2] && explicitDate[3]) {
+    const month = MONTHS[explicitDate[1].toLowerCase()];
+    const day = Number(explicitDate[2]);
+    const time2 = parseTimeToken(explicitDate[3]);
+    if (!month || !Number.isFinite(day) || !time2) return void 0;
+    let candidate2 = dateInTimeZone({ year: nowParts.year, month, day, ...time2 }, timeZone);
+    if (candidate2 && candidate2.getTime() <= now.getTime()) {
+      candidate2 = dateInTimeZone({ year: nowParts.year + 1, month, day, ...time2 }, timeZone);
+    }
+    return candidate2?.toISOString();
+  }
+  const dayMonthDate = /^(.+?)\s+on\s+(\d{1,2})\s+([A-Za-z]{3,9})$/i.exec(body);
+  if (dayMonthDate?.[1] && dayMonthDate[2] && dayMonthDate[3]) {
+    const time2 = parseTimeToken(dayMonthDate[1]);
+    const day = Number(dayMonthDate[2]);
+    const month = MONTHS[dayMonthDate[3].toLowerCase()];
+    if (!month || !Number.isFinite(day) || !time2) return void 0;
+    let candidate2 = dateInTimeZone({ year: nowParts.year, month, day, ...time2 }, timeZone);
+    if (candidate2 && candidate2.getTime() <= now.getTime()) {
+      candidate2 = dateInTimeZone({ year: nowParts.year + 1, month, day, ...time2 }, timeZone);
+    }
+    return candidate2?.toISOString();
+  }
+  const time = parseTimeToken(body);
+  if (!time) return void 0;
+  let candidateParts = { ...nowParts, ...time };
+  let candidate = dateInTimeZone(candidateParts, timeZone);
+  if (candidate && candidate.getTime() <= now.getTime()) {
+    candidateParts = addCalendarDays(candidateParts, 1);
+    candidate = dateInTimeZone(candidateParts, timeZone);
+  }
+  return candidate?.toISOString();
+}
+function makeWindow(kind, label, usedPercent, windowMinutes, resetDescription, now, model) {
+  return {
+    provider: "claude",
+    kind,
+    label,
+    usedPercent,
+    remainingPercent: remainingPercentFromUsed(usedPercent),
+    resetDescription,
+    resetsAt: parseResetDate(resetDescription, now),
+    windowMinutes,
+    source: "claude-usage-tmux",
+    model
+  };
+}
+function extractWindow(lines, labelNeedles, kind, label, windowMinutes, now, model, excludeNeedles = []) {
+  const index = lines.findIndex((line) => {
+    const normalized = normalizeLabel(line);
+    return labelNeedles.some((needle) => normalized.includes(normalizeLabel(needle))) && !excludeNeedles.some((needle) => normalized.includes(normalizeLabel(needle)));
+  });
+  if (index === -1) return null;
+  const candidates = lines.slice(index, index + 12);
+  const usedPercent = candidates.map(parseUsedPercent).find((value) => value !== null);
+  if (usedPercent === void 0) return null;
+  const resetDescription = candidates.map(parseResetDescription).find((value) => Boolean(value));
+  return makeWindow(kind, label, usedPercent, windowMinutes, resetDescription, now, model);
+}
+function parseCompactUsageRow(line) {
+  const match = /^resets?\s+(.+?)\s+([0-9]{1,3}(?:\.[0-9]+)?)\s*%\s*(used|spent|consumed|remaining|left|available)\b/i.exec(line);
+  if (!match?.[1] || !match[2] || !match[3]) return null;
+  const percent = clampPercent2(Number(match[2]));
+  const mode = match[3].toLowerCase();
+  const usedPercent = mode === "used" || mode === "spent" || mode === "consumed" ? percent : remainingPercentFromUsed(percent);
+  return {
+    resetDescription: match[1].trim(),
+    usedPercent
+  };
+}
+function parseCompactUsageRows(lines, now) {
+  const rows = lines.map(parseCompactUsageRow).filter((row) => row !== null);
+  const specs = [
+    { kind: "session", label: "Session (5h)", windowMinutes: 300 },
+    { kind: "weekly", label: "Weekly (7 day)", windowMinutes: 10080 },
+    { kind: "model-weekly", label: "Sonnet Weekly (7 day)", windowMinutes: 10080, model: "Sonnet" }
+  ];
+  return rows.slice(0, specs.length).map((row, index) => {
+    const spec = specs[index];
+    return makeWindow(
+      spec.kind,
+      spec.label,
+      row.usedPercent,
+      spec.windowMinutes,
+      row.resetDescription,
+      now,
+      spec.model
+    );
+  });
+}
+function parseClaudeUsageText(text, now = /* @__PURE__ */ new Date()) {
+  const lines = normalizeTerminalText(text).split("\n").map((line) => line.trim()).filter(Boolean);
+  const compactWindows = parseCompactUsageRows(lines, now);
+  if (compactWindows.length > 0) return compactWindows;
+  const windows = [];
+  const session = extractWindow(lines, ["Current session"], "session", "Session (5h)", 300, now);
+  const weekly = extractWindow(
+    lines,
+    ["Current week (all models)", "Current week"],
+    "weekly",
+    "Weekly (7 day)",
+    10080,
+    now,
+    void 0,
+    ["sonnet", "opus"]
+  );
+  const sonnet = extractWindow(
+    lines,
+    ["Current week (Sonnet only)", "Current week (Sonnet)"],
+    "model-weekly",
+    "Sonnet Weekly (7 day)",
+    10080,
+    now,
+    "Sonnet"
+  );
+  const opus = extractWindow(
+    lines,
+    ["Current week (Opus)"],
+    "model-weekly",
+    "Opus Weekly (7 day)",
+    10080,
+    now,
+    "Opus"
+  );
+  if (session) windows.push(session);
+  if (weekly) windows.push(weekly);
+  if (sonnet) windows.push(sonnet);
+  if (opus) windows.push(opus);
+  return windows;
+}
+function isClaudePromptReady(text) {
+  const normalized = normalizeTerminalText(text);
+  return /Claude Code v\d+\.\d+\.\d+/.test(normalized) && (normalized.includes("\u276F") || normalized.includes(">"));
+}
+function execFileCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile2(
+      command,
+      [...args],
+      {
+        cwd: options.cwd,
+        timeout: options.timeoutMs ?? 2e3,
+        maxBuffer: 1024 * 1024
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve({ stdout, stderr });
+      }
+    );
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveDefaultClaudeUsageCwd() {
+  const envCwd = process.env.VIBESTATS_CLAUDE_USAGE_CWD ?? process.env.VIBESTATS_USAGE_CWD;
+  if (envCwd?.trim()) return envCwd;
+  return dirname(fileURLToPath(import.meta.url));
+}
+async function captureUsageWithTmux(options) {
+  const sessionName = `${TMUX_SESSION_PREFIX}-${randomUUID().replaceAll("-", "").slice(0, 16)}`;
+  let started = false;
+  const runTmux = (args, timeoutMs = 2e3) => options.runCommand("tmux", args, { cwd: options.cwd, timeoutMs });
+  try {
+    await runTmux([
+      "new-session",
+      "-d",
+      "-s",
+      sessionName,
+      "-x",
+      "120",
+      "-y",
+      "40",
+      ...options.cwd ? ["-c", options.cwd] : [],
+      options.command
+    ], 5e3);
+    started = true;
+    const startedAt = Date.now();
+    const deadline = startedAt + options.timeoutMs;
+    let lastUsageCommandAt = null;
+    let promptReady = false;
+    while (Date.now() < deadline) {
+      await options.sleepFn(POLL_INTERVAL_MS);
+      const capture = await runTmux([
+        "capture-pane",
+        "-p",
+        "-J",
+        "-S",
+        "-",
+        "-E",
+        "-",
+        "-t",
+        sessionName
+      ]);
+      const windows = parseClaudeUsageText(capture.stdout, options.now);
+      if (windows.length > 0) {
+        return windows;
+      }
+      const now = Date.now();
+      promptReady = promptReady || isClaudePromptReady(capture.stdout);
+      const waitedLongEnough = now - startedAt >= Math.min(READY_FALLBACK_MS, options.timeoutMs / 2);
+      const shouldSendUsage = (promptReady || waitedLongEnough) && (lastUsageCommandAt === null || now - lastUsageCommandAt >= USAGE_COMMAND_RETRY_MS);
+      if (shouldSendUsage) {
+        await runTmux(["send-keys", "-t", sessionName, "/usage", "Enter"]);
+        lastUsageCommandAt = now;
+      }
+    }
+    return [];
+  } finally {
+    if (started) {
+      await runTmux(["kill-session", "-t", sessionName]).catch(() => void 0);
+    }
+  }
+}
+async function fetchClaudeLimits(options = {}) {
+  const command = options.command || "claude";
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  let windows;
+  try {
+    windows = await captureUsageWithTmux({
+      command,
+      cwd: options.cwd ?? resolveDefaultClaudeUsageCwd(),
+      timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      now,
+      runCommand: options.runCommand ?? execFileCommand,
+      sleepFn: options.sleepFn ?? sleep
+    });
+  } catch (error) {
+    return {
+      provider: "claude",
+      source: "claude-usage-tmux",
+      windows: [],
+      pace: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (windows.length === 0) {
+    return {
+      provider: "claude",
+      source: "claude-usage-tmux",
+      windows: [],
+      pace: [],
+      error: "could not parse claude /usage output"
+    };
+  }
+  return {
+    provider: "claude",
+    source: "claude-usage-tmux",
+    windows,
+    pace: computeLinearPaces(windows, now)
+  };
+}
+
+// src/limits/codex.ts
+import { spawn } from "child_process";
+function clampPercent3(value) {
+  const numeric = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(numeric)) return 0;
+  return Math.max(0, Math.min(100, numeric));
+}
+function isoFromUnixSeconds(value) {
+  const seconds = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(seconds) || seconds <= 0) return void 0;
+  return new Date(seconds * 1e3).toISOString();
+}
+function sourceLabel(kind, model) {
+  const suffix = kind === "session" || kind === "model-session" ? "Session (5h)" : "Weekly (7 day)";
+  return model ? `${model} ${suffix}` : suffix;
+}
+function stripAnsi2(text) {
+  return text.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+function parsePercentLeft(line) {
+  const match = /([0-9]{1,3}(?:\.[0-9]+)?)\s*%\s+(?:left|remaining|available)/i.exec(line);
+  if (!match) return null;
+  return clampPercent3(match[1]);
+}
+function parseResetDescription2(line) {
+  const match = /\bresets?\s+(.+)$/i.exec(line);
+  return match?.[1]?.trim() || void 0;
+}
+function makeWindow2(bucket, rawWindow, kind, model) {
+  if (!rawWindow) return null;
+  const usedPercent = clampPercent3(rawWindow.usedPercent);
+  const windowMinutes = typeof rawWindow.windowDurationMins === "number" ? rawWindow.windowDurationMins : void 0;
+  return {
+    provider: "codex",
+    kind,
+    label: sourceLabel(kind, model),
+    usedPercent,
+    remainingPercent: Math.max(0, Math.round((100 - usedPercent) * 100) / 100),
+    resetsAt: isoFromUnixSeconds(rawWindow.resetsAt),
+    windowMinutes,
+    source: "codex-app-server",
+    limitId: bucket.limitId,
+    model
+  };
+}
+function normalizeCodexRateLimitWindows(payload) {
+  const windows = [];
+  const primaryBucket = payload.rateLimits;
+  const primaryLimitId = primaryBucket?.limitId;
+  if (primaryBucket) {
+    const primary = makeWindow2(primaryBucket, primaryBucket.primary, "session");
+    const secondary = makeWindow2(primaryBucket, primaryBucket.secondary, "weekly");
+    if (primary) windows.push(primary);
+    if (secondary) windows.push(secondary);
+  }
+  for (const [limitId, bucket] of Object.entries(payload.rateLimitsByLimitId || {})) {
+    if (limitId === primaryLimitId) continue;
+    const model = typeof bucket.limitName === "string" && bucket.limitName.trim() ? bucket.limitName.trim() : void 0;
+    const normalizedBucket = { ...bucket, limitId: bucket.limitId || limitId };
+    const primary = makeWindow2(normalizedBucket, bucket.primary, "model-session", model);
+    const secondary = makeWindow2(normalizedBucket, bucket.secondary, "model-weekly", model);
+    if (primary) windows.push(primary);
+    if (secondary) windows.push(secondary);
+  }
+  return windows;
+}
+function parseCodexStatusText(text) {
+  const clean = stripAnsi2(text);
+  const lines = clean.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const windows = [];
+  const specs = [
+    { pattern: /\b5(?:h|-hour)\s+limit\b/i, kind: "session", windowMinutes: 300 },
+    { pattern: /\bweekly\s+limit\b/i, kind: "weekly", windowMinutes: 10080 }
+  ];
+  for (const spec of specs) {
+    const line = lines.find((candidate) => spec.pattern.test(candidate));
+    if (!line) continue;
+    const remainingPercent = parsePercentLeft(line);
+    if (remainingPercent === null) continue;
+    const usedPercent = Math.max(0, Math.round((100 - remainingPercent) * 100) / 100);
+    windows.push({
+      provider: "codex",
+      kind: spec.kind,
+      label: sourceLabel(spec.kind),
+      usedPercent,
+      remainingPercent,
+      resetDescription: parseResetDescription2(line),
+      windowMinutes: spec.windowMinutes,
+      source: "codex-status-pty"
+    });
+  }
+  return windows;
+}
+function unwrapRateLimitsResult(result) {
+  const outer = result;
+  const nested = outer.rateLimits;
+  const payload = nested && typeof nested === "object" && ("rateLimits" in nested || "rateLimitsByLimitId" in nested) ? outer.rateLimits : result;
+  return payload;
+}
+function unwrapAccountResult(result) {
+  const payload = result;
+  const account = payload.account;
+  if (!account && typeof payload.requiresOpenaiAuth !== "boolean") return void 0;
+  return {
+    provider: "codex",
+    accountType: account?.type,
+    planType: account?.planType,
+    requiresAuth: payload.requiresOpenaiAuth
+  };
+}
+var JsonRpcClient = class {
+  constructor(child) {
+    this.child = child;
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => this.handleOutput(chunk));
+    child.stdin.on("error", (error) => this.rejectAll(error instanceof Error ? error : new Error(String(error))));
+    child.on("error", (error) => this.rejectAll(error instanceof Error ? error : new Error(String(error))));
+    child.on("exit", (code) => {
+      if (this.pending.size > 0) {
+        this.rejectAll(new Error(`codex app-server exited before response${code === null ? "" : ` (${code})`}`));
+      }
+    });
+  }
+  nextId = 1;
+  buffer = "";
+  pending = /* @__PURE__ */ new Map();
+  request(method, params) {
+    const id = this.nextId++;
+    const message = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      ...params === void 0 ? {} : { params }
+    };
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+    });
+    try {
+      this.child.stdin.write(`${JSON.stringify(message)}
+`);
+    } catch (error) {
+      this.pending.delete(id);
+      return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+    return promise;
+  }
+  notify(method, params) {
+    const message = {
+      jsonrpc: "2.0",
+      method,
+      ...params === void 0 ? {} : { params }
+    };
+    try {
+      this.child.stdin.write(`${JSON.stringify(message)}
+`);
+    } catch {
+    }
+  }
+  handleOutput(chunk) {
+    this.buffer += chunk;
+    let newlineIndex = this.buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = this.buffer.slice(0, newlineIndex).trim();
+      this.buffer = this.buffer.slice(newlineIndex + 1);
+      this.handleLine(line);
+      newlineIndex = this.buffer.indexOf("\n");
+    }
+  }
+  handleLine(line) {
+    if (!line.startsWith("{")) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (typeof message.id !== "number") return;
+    const pending = this.pending.get(message.id);
+    if (!pending) return;
+    this.pending.delete(message.id);
+    if (message.error) {
+      const msg = typeof message.error === "string" ? message.error : message.error.message || "JSON-RPC error";
+      pending.reject(new Error(msg));
+    } else {
+      pending.resolve(message.result);
+    }
+  }
+  rejectAll(error) {
+    for (const pending of this.pending.values()) {
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+};
+function withTimeout(promise, timeoutMs) {
+  let timer = null;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error("codex app-server timed out")), timeoutMs);
+    timer.unref();
+  });
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+function scriptArgsForCodexStatus(command) {
+  const quotedCommand = `'${command.replace(/'/g, "'\\''")}'`;
+  const shellCommand = `printf '/status\\n' | ${quotedCommand} -s read-only -a untrusted`;
+  if (process.platform === "darwin") {
+    return ["-q", "/dev/null", "sh", "-c", shellCommand];
+  }
+  return ["-q", "-c", shellCommand, "/dev/null"];
+}
+async function fetchCodexStatusFallback(options = {}) {
+  const command = options.command || "codex";
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  const child = spawn("script", scriptArgsForCodexStatus(command), {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env
+  });
+  let output = "";
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    output += chunk;
+  });
+  child.stderr.on("data", (chunk) => {
+    output += chunk;
+  });
+  await new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      resolve();
+    }, timeoutMs);
+    timer.unref();
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    child.on("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+  const windows = parseCodexStatusText(output);
+  if (windows.length === 0) {
+    return {
+      provider: "codex",
+      source: "codex-status-pty",
+      windows: [],
+      pace: [],
+      error: "could not parse codex /status output"
+    };
+  }
+  return {
+    provider: "codex",
+    source: "codex-status-pty",
+    windows,
+    pace: computeLinearPaces(windows, options.now)
+  };
+}
+async function fetchCodexLimits(options = {}) {
+  const command = options.command || "codex";
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  const child = spawn(command, ["-s", "read-only", "-a", "untrusted", "app-server"], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: process.env
+  });
+  let stderr = "";
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+  const client = new JsonRpcClient(child);
+  try {
+    await withTimeout(
+      client.request("initialize", { clientInfo: { name: "vibestats", version: "1" } }),
+      timeoutMs
+    );
+    client.notify("initialized");
+    const [rateLimitsResult, accountResult] = await withTimeout(
+      Promise.all([
+        client.request("account/rateLimits/read"),
+        client.request("account/read").catch(() => null)
+      ]),
+      timeoutMs
+    );
+    const payload = unwrapRateLimitsResult(rateLimitsResult);
+    const windows = normalizeCodexRateLimitWindows(payload);
+    const pace = computeLinearPaces(windows, options.now);
+    return {
+      provider: "codex",
+      source: "codex-app-server",
+      windows,
+      pace,
+      account: accountResult ? unwrapAccountResult(accountResult) : void 0
+    };
+  } catch (error) {
+    child.kill("SIGTERM");
+    const appServerError = error instanceof Error ? error.message : String(error || stderr);
+    const fallback = await fetchCodexStatusFallback(options);
+    return fallback.windows.length > 0 ? fallback : {
+      provider: "codex",
+      source: "codex-app-server",
+      windows: [],
+      pace: [],
+      error: `${appServerError}; ${fallback.error || "codex /status fallback failed"}`
+    };
+  } finally {
+    child.kill("SIGTERM");
+  }
+}
+
+// src/limits/index.ts
+function selectedProviders(options) {
+  if (options.codexOnly) return ["codex"];
+  if (options.combined) return ["claude", "codex"];
+  return ["claude"];
+}
+async function loadUsageLimits(options = {}) {
+  const providers = selectedProviders(options);
+  const snapshots = await Promise.all(
+    providers.map((provider) => {
+      if (provider === "codex") {
+        return fetchCodexLimits({ timeoutMs: options.timeoutMs });
+      }
+      return fetchClaudeLimits({ timeoutMs: options.timeoutMs });
+    })
+  );
+  return {
+    snapshots,
+    windows: snapshots.flatMap((snapshot) => snapshot.windows),
+    pace: snapshots.flatMap((snapshot) => snapshot.pace),
+    accounts: snapshots.map((snapshot) => snapshot.account).filter((account) => Boolean(account)),
+    errors: snapshots.filter((snapshot) => snapshot.error).map((snapshot) => ({
+      provider: snapshot.provider,
+      source: snapshot.source,
+      message: snapshot.error || "unknown error"
+    }))
+  };
+}
+
+// src/limits/table.ts
+var colors3 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  orange: "\x1B[38;5;208m",
+  amber: "\x1B[38;5;214m",
+  green: "\x1B[32m",
+  blue: "\x1B[34m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m"
+};
+var noColors3 = Object.fromEntries(Object.keys(colors3).map((k) => [k, ""]));
+function getColors3(showColors) {
+  return showColors === false ? noColors3 : colors3;
+}
+function formatProvider(provider) {
+  return provider === "codex" ? "Codex" : provider === "claude" ? "Claude" : provider;
+}
+function formatReset(window) {
+  if (window.resetsAt) {
+    const ms = new Date(window.resetsAt).getTime() - Date.now();
+    if (Number.isFinite(ms) && ms > 0) return `resets in ${formatDuration(ms)}`;
+  }
+  if (window.resetDescription) return `resets ${window.resetDescription}`;
+  return "reset unknown";
+}
+function formatDuration(ms) {
+  const totalMinutes = Math.max(0, Math.round(ms / 6e4));
+  const days = Math.floor(totalMinutes / 1440);
+  const hours = Math.floor(totalMinutes % 1440 / 60);
+  const minutes = totalMinutes % 60;
+  if (days > 0) return `${days}d ${hours}h`;
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+function providerBarColor(provider, showColors) {
+  const c = getColors3(showColors);
+  return provider === "codex" ? c.blue : c.green;
+}
+function bar(window, showColors) {
+  const c = getColors3(showColors);
+  const width = 20;
+  const filled = Math.round(Math.max(0, Math.min(100, window.usedPercent)) / 100 * width);
+  return `${providerBarColor(window.provider, showColors)}${"\u2588".repeat(filled)}${c.gray}${"\u2591".repeat(width - filled)}${c.reset}`;
+}
+function findPace(window, paces) {
+  return paces.find(
+    (pace) => pace.provider === window.provider && pace.kind === window.kind && pace.label === window.label
+  );
+}
+function paceLine(pace) {
+  if (!pace) return null;
+  const amount = Math.abs(pace.deltaPercent).toFixed(1);
+  const status = pace.status === "reserve" ? `${amount}% reserve` : pace.status === "deficit" ? `${amount}% deficit` : "on pace";
+  const eta = pace.lastsUntilReset ? "lasts until reset" : pace.runsOutAt ? `runs out in ${formatDuration(new Date(pace.runsOutAt).getTime() - Date.now())}` : "run-out unknown";
+  return `${status} \xB7 ${eta} \xB7 expected ${pace.expectedUsedPercent.toFixed(1)}% used`;
+}
+function displayUsageLimits(limits, options = {}) {
+  const c = getColors3(options.showColors);
+  console.log();
+  console.log(`${c.orange}${c.bold}Local CLI Limits${c.reset}`);
+  console.log(`${c.gray}Sources: Codex app-server with /status fallback; Claude /usage tmux${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(72)}${c.reset}`);
+  if (limits.windows.length === 0) {
+    console.log(`${c.gray}No live limit windows available.${c.reset}`);
+  }
+  for (const window of limits.windows) {
+    const pace = findPace(window, limits.pace);
+    const paceText = paceLine(pace);
+    const riskColor = window.usedPercent >= 90 ? c.red : window.usedPercent >= 70 ? c.amber : c.green;
+    console.log(
+      `${c.bold}${formatProvider(window.provider)} ${window.label}${c.reset} ${bar(window, options.showColors)} ${riskColor}${window.usedPercent.toFixed(0)}% used${c.reset} ${c.gray}${formatReset(window)} \xB7 ${window.source}${c.reset}`
+    );
+    if (paceText) {
+      console.log(`  ${c.dim}${paceText}${c.reset}`);
+    }
+  }
+  if (limits.errors.length > 0) {
+    console.log();
+    for (const error of limits.errors) {
+      console.log(`${c.gray}${formatProvider(error.provider)} ${error.source}: ${error.message}${c.reset}`);
+    }
+  }
+}
+
 // src/config.ts
 import { readFileSync, existsSync, writeFileSync } from "fs";
 import { homedir as homedir4 } from "os";
@@ -3298,6 +4383,20 @@ function getSelectedModelFamilies(args) {
 }
 
 // src/index.ts
+function printCommandHelp(error) {
+  console.error(`Error: ${error}`);
+  console.error("");
+  console.error("Usage:");
+  console.error("  vibestats limits all");
+  console.error("  vibestats limits claude");
+  console.error("  vibestats limits codex");
+  console.error("  vibestats usage all");
+  console.error("  vibestats usage --combined --daily");
+  console.error("  vibestats usage codex --total");
+  console.error("  vibestats wrapped");
+  console.error("");
+  console.error("Run `vibestats --help` for all flags.");
+}
 function createSpinner(label = "Loading vibestats...") {
   const spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   const orange = "\x1B[38;5;208m";
@@ -3440,7 +4539,7 @@ async function publishArtifactWithFallback(artifact, baseUrl, fallbackUrl, prefe
 var main = defineCommand({
   meta: {
     name: "vibestats",
-    version: "1.3.10",
+    version: "1.3.13",
     description: "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex"
   },
   args: {
@@ -3523,6 +4622,11 @@ var main = defineCommand({
       description: "Use compact table format (hide cache columns)",
       default: false
     },
+    limits: {
+      type: "boolean",
+      description: "Include live local CLI limit windows (Codex app-server or PTY, Claude /usage PTY)",
+      default: false
+    },
     metric: {
       type: "string",
       description: "Activity metric: tokens, sessions, or messages"
@@ -3583,30 +4687,40 @@ var main = defineCommand({
     }
   },
   async run({ args }) {
-    if (args.init) {
+    const intent = resolveCliIntent(process.argv.slice(2));
+    if (intent.error) {
+      printCommandHelp(intent.error.message);
+      process.exit(1);
+    }
+    const normalizedArgs = applyCliIntent(args, intent);
+    if (normalizedArgs.init) {
       initConfig();
       return;
     }
     const config = loadConfig();
-    if (args.config) {
+    if (normalizedArgs.config) {
       console.log(`Config file: ${CONFIG_PATH}`);
       console.log(JSON.stringify(config, null, 2));
       return;
     }
-    if (args["claude-system"]) {
-      await runClaudeSystem(args);
+    if (normalizedArgs["claude-system"]) {
+      await runClaudeSystem(normalizedArgs);
+      return;
+    }
+    if (normalizedArgs["claude-limits"]) {
+      await runClaudeLimits(normalizedArgs);
       return;
     }
-    if (args["claude-limits"]) {
-      await runClaudeLimits(args);
+    if (intent.command === "limits") {
+      await runLiveLimits(normalizedArgs, config);
       return;
     }
-    if (args.activity) {
-      await runActivity(args, config);
-    } else if (args.wrapped) {
-      await runWrapped(args, config);
+    if (normalizedArgs.activity) {
+      await runActivity(normalizedArgs, config);
+    } else if (normalizedArgs.wrapped) {
+      await runWrapped(normalizedArgs, config);
     } else {
-      await runUsage(args, config);
+      await runUsage(normalizedArgs, config);
     }
   }
 });
@@ -3635,19 +4749,18 @@ async function runUsage(args, config) {
   else if (args.monthly) aggregation = "monthly";
   else if (args.model) aggregation = "model";
   else if (args.total) aggregation = "total";
-  const spinner = createSpinner("Loading vibestats...");
-  const stats = await spinner.whilePromise(
-    loadUsageStats({
-      aggregation,
-      since,
-      until,
-      codexOnly: args.codex,
-      combined: args.combined,
-      projectFilter: args.project ? process.cwd() : void 0,
-      families,
-      scopeLabel
-    })
-  );
+  const shouldShowSpinner = !args.json && !args.quiet;
+  const statsPromise = loadUsageStats({
+    aggregation,
+    since,
+    until,
+    codexOnly: args.codex,
+    combined: args.combined,
+    projectFilter: args.project ? process.cwd() : void 0,
+    families,
+    scopeLabel
+  });
+  const stats = shouldShowSpinner ? await createSpinner("Loading vibestats...").whilePromise(statsPromise) : await statsPromise;
   if (!stats) {
     if (requestedSince || requestedUntil || requestedLastDays) {
       const rangeStr = `${since || "(start)"} to ${until || "(end)"}`;
@@ -3674,6 +4787,18 @@ async function runUsage(args, config) {
     }
     process.exit(1);
   }
+  let liveLimits = null;
+  if (args.limits) {
+    const limitsPromise = loadUsageLimits({
+      codexOnly: args.codex,
+      combined: args.combined
+    });
+    liveLimits = shouldShowSpinner ? await createSpinner("Loading local CLI limits...").whilePromise(limitsPromise) : await limitsPromise;
+    stats.limits = liveLimits.windows;
+    stats.pace = liveLimits.pace;
+    stats.limitAccounts = liveLimits.accounts;
+    stats.limitErrors = liveLimits.errors;
+  }
   const baseUrl = args.url || config.baseUrl || "https://vibestats.wolfai.dev";
   let shareUrl = null;
   if (args.share) {
@@ -3708,6 +4833,11 @@ async function runUsage(args, config) {
       showColors: config.theme?.enabled !== false
     });
   }
+  if (liveLimits && !args.json && !args.quiet) {
+    displayUsageLimits(liveLimits, {
+      showColors: config.theme?.enabled !== false
+    });
+  }
   if (args.share && shareUrl && !args.json) {
     const orange = "\x1B[38;5;208m";
     const reset = "\x1B[0m";
@@ -3715,6 +4845,20 @@ async function runUsage(args, config) {
     console.log(`\u{1F517} ${orange}${shareUrl}${reset}`);
   }
 }
+async function runLiveLimits(args, config) {
+  const limitsPromise = loadUsageLimits({
+    codexOnly: args.codex,
+    combined: args.combined
+  });
+  const limits = args.json || args.quiet ? await limitsPromise : await createSpinner("Loading local CLI limits...").whilePromise(limitsPromise);
+  if (args.json) {
+    console.log(JSON.stringify(limits, null, 2));
+    return;
+  }
+  displayUsageLimits(limits, {
+    showColors: config.theme?.enabled !== false
+  });
+}
 async function runWrapped(args, config) {
   const options = resolveOptions(args, config);
   const families = getSelectedModelFamilies(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibestats",
-  "version": "1.3.11",
+  "version": "1.3.13",
   "description": "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex",
   "type": "module",
   "main": "./dist/index.js",