ccusage 14.1.2 → 15.0.0

package/README.md

@@ -15,6 +15,10 @@
     <img src="https://cdn.jsdelivr.net/gh/ryoppippi/ccusage@main/docs/screenshot.png">
 </div>
 
+<div align="center">
+    <img src="https://cdn.jsdelivr.net/gh/ryoppippi/ccusage@main/docs/blocks-live.png">
+</div>
+
 > **ccusage(claude-code-usage)**
 
 A CLI tool for analyzing Claude Code usage from local JSONL files.
@@ -48,6 +52,7 @@ This tool helps you understand the value you're getting from your subscription b
 - 📅 **Monthly Report**: View token usage and costs aggregated by month
 - 💬 **Session Report**: View usage grouped by conversation sessions
 - ⏰ **5-Hour Blocks Report**: Track usage within Claude's billing windows with active block monitoring
+- 📈 **Live Monitoring**: Real-time dashboard showing active session progress, token burn rate, and cost projections with `blocks --live`
 - 🤖 **Model Tracking**: See which Claude models you're using (Opus, Sonnet, etc.)
 - 📊 **Model Breakdown**: View per-model cost breakdown with `--breakdown` flag
 - 📅 **Date Filtering**: Filter reports by date range using `--since` and `--until`
@@ -284,6 +289,13 @@ ccusage blocks -t 500000
 # Use the highest previous block as the token limit
 ccusage blocks -t max
 
+# Live monitoring dashboard with real-time updates
+ccusage blocks --live # automatically uses highest previous session as token limit (-t max)
+ccusage blocks --live -t 500000  # with explicit token limit (500,000 tokens)
+ccusage blocks --live -t max     # explicitly use highest previous session limit
+ccusage blocks --live --refresh-interval 5  # update every 5 seconds (default: 1s)
+ccusage blocks --live -t 1000000 --refresh-interval 2  # 1M token limit, 2s refresh
+
 # Combine options
 ccusage blocks --recent -t max
 
@@ -307,11 +319,23 @@ The blocks report helps you understand Claude Code's 5-hour rolling session wind
 - Helps track if you're approaching token limits within a session
 - The `-t max` option automatically uses your highest previous block as the limit
 
+**Live Monitoring Features:**
+
+- Real-time dashboard updates every 1 second (configurable 1-60s)
+- Automatic token limit detection from your usage history
+- Session progress bar with time remaining and burn rate
+- Cost projections based on current usage patterns
+- Colorful progress indicators (green/yellow/red for quota warnings)
+- Graceful shutdown with Ctrl+C
+
 #### Blocks-specific options
 
 - `-t, --token-limit <number|max>`: Set token limit for quota warnings (use "max" for highest previous block)
 - `-a, --active`: Show only active block with detailed projections
 - `-r, --recent`: Show blocks from last 3 days (including active)
+- `-l, --session-length <hours>`: Session block duration in hours (default: 5)
+- `--live`: Live monitoring mode with real-time dashboard (automatically uses `-t max` and shows active block only)
+- `--refresh-interval <seconds>`: Refresh interval for live mode (default: 1, range: 1-60)
 
 ### Options
 
@@ -565,6 +589,8 @@ some projects use `ccusage` internally and provide additional features:
 
 - [claude-usage-tracker-for-mac](https://github.com/penicillin0/claude-usage-tracker-for-mac) – macOS menu bar app to visualize Claude Code usage costs by [@penicillin0](https://github.com/penicillin0).
 - [ccusage Raycast Extension](https://www.raycast.com/nyatinte/ccusage) – Raycast extension to view Claude Code usage reports in Raycast by [@nyatinte](https://github.com/nyatinte).
+- [claude-code-usage-monitor](https://github.com/Maciek-roboblog/Claude-Code-Usage-Monitor) – A real-time terminal-based tool for monitoring Claude Code token usage. It displays live token consumption, burn rate, and depletion predictions, with session-aware analytics, visual progress bars, and support for multiple subscription plans by [@Maciek-roboblog](https://github.com/Maciek-roboblog).
+- [ClaudeCode_Dashboard](https://github.com/m-sigepon/ClaudeCode_Dashboard) – Web dashboard to visualize Claude Code usage with charts and USD/JPY conversion by [@m-sigepon](https://github.com/m-sigepon).
 
 ## Acknowledgments
 

package/dist/calculate-cost.d.ts

@@ -1,5 +1,5 @@
 import "./pricing-fetcher-CXnYw4TA.js";
-import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-C1n0ww95.js";
+import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-Bll0wMdK.js";
 
 //#region src/calculate-cost.d.ts
 /**

package/dist/{data-loader-BFS_JSqd.js → data-loader-B_ymgjWR.js}

@@ -1,6 +1,6 @@
-import { CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, require_usingCtx } from "./pricing-fetcher-XdvIG0to.js";
+import { CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, require_usingCtx } from "./pricing-fetcher-CMyU5JUX.js";
 import { activityDateSchema, arrayType, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, dailyDateSchema, isoTimestampSchema, messageIdSchema, modelNameSchema, monthlyDateSchema, numberType, objectType, projectPathSchema, requestIdSchema, sessionIdSchema, versionSchema } from "./_types-Cr2YEzKm.js";
-import { logger } from "./logger-CIYlc309.js";
+import { logger } from "./logger-6I_KKR-u.js";
 import a, { readFile } from "node:fs/promises";
 import F, { homedir } from "node:os";
 import path, { posix } from "node:path";
@@ -3869,4 +3869,4 @@ async function loadSessionBlockData(options) {
 		_usingCtx4.d();
 	}
 }
-export { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, filterRecentBlocks, formatDate, formatDateCompact, getClaudePaths, getDefaultClaudePath, getEarliestTimestamp, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, uniq, usageDataSchema };
+export { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, filterRecentBlocks, formatDate, formatDateCompact, getClaudePaths, getDefaultClaudePath, getEarliestTimestamp, glob, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, uniq, usageDataSchema };

package/dist/{data-loader-C1n0ww95.d.ts → data-loader-Bll0wMdK.d.ts}

@@ -91,8 +91,8 @@ declare const usageDataSchema: z.ZodObject<{
       cache_creation_input_tokens?: number | undefined;
       cache_read_input_tokens?: number | undefined;
     };
-    model?: string & z.BRAND<"ModelName"> | undefined;
-    id?: string & z.BRAND<"MessageId"> | undefined;
+    model?: (string & z.BRAND<"ModelName">) | undefined;
+    id?: (string & z.BRAND<"MessageId">) | undefined;
   }, {
     usage: {
       input_tokens: number;
@@ -107,7 +107,7 @@ declare const usageDataSchema: z.ZodObject<{
   requestId: z.ZodOptional<z.ZodBranded<z.ZodString, "RequestId">>;
 }, "strip", z.ZodTypeAny, {
   timestamp: string & z.BRAND<"ISOTimestamp">;
-  version?: string & z.BRAND<"Version"> | undefined;
+  version?: (string & z.BRAND<"Version">) | undefined;
   message: {
     usage: {
       input_tokens: number;
@@ -115,11 +115,11 @@ declare const usageDataSchema: z.ZodObject<{
       cache_creation_input_tokens?: number | undefined;
       cache_read_input_tokens?: number | undefined;
     };
-    model?: string & z.BRAND<"ModelName"> | undefined;
-    id?: string & z.BRAND<"MessageId"> | undefined;
+    model?: (string & z.BRAND<"ModelName">) | undefined;
+    id?: (string & z.BRAND<"MessageId">) | undefined;
   };
   costUSD?: number | undefined;
-  requestId?: string & z.BRAND<"RequestId"> | undefined;
+  requestId?: (string & z.BRAND<"RequestId">) | undefined;
 }, {
   timestamp: string;
   version?: string | undefined;

package/dist/data-loader.d.ts

@@ -1,3 +1,3 @@
 import "./pricing-fetcher-CXnYw4TA.js";
-import { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-C1n0ww95.js";
+import { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-Bll0wMdK.js";
 export { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/data-loader.js

@@ -1,5 +1,5 @@
-import "./pricing-fetcher-XdvIG0to.js";
+import "./pricing-fetcher-CMyU5JUX.js";
 import "./_types-Cr2YEzKm.js";
-import { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-BFS_JSqd.js";
-import "./logger-CIYlc309.js";
+import { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-B_ymgjWR.js";
+import "./logger-6I_KKR-u.js";
 export { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/{debug-DIfzQVQt.js → debug-2jwq04IT.js}

@@ -1,6 +1,6 @@
-import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, require_usingCtx } from "./pricing-fetcher-XdvIG0to.js";
-import { getDefaultClaudePath, glob, usageDataSchema } from "./data-loader-BFS_JSqd.js";
-import { logger } from "./logger-CIYlc309.js";
+import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, require_usingCtx } from "./pricing-fetcher-CMyU5JUX.js";
+import { getDefaultClaudePath, glob, usageDataSchema } from "./data-loader-B_ymgjWR.js";
+import { logger } from "./logger-6I_KKR-u.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 var import_usingCtx = __toESM(require_usingCtx(), 1);

package/dist/debug.js

@@ -1,6 +1,6 @@
-import "./pricing-fetcher-XdvIG0to.js";
+import "./pricing-fetcher-CMyU5JUX.js";
 import "./_types-Cr2YEzKm.js";
-import "./data-loader-BFS_JSqd.js";
-import "./logger-CIYlc309.js";
-import { detectMismatches, printMismatchReport } from "./debug-DIfzQVQt.js";
+import "./data-loader-B_ymgjWR.js";
+import "./logger-6I_KKR-u.js";
+import { detectMismatches, printMismatchReport } from "./debug-2jwq04IT.js";
 export { detectMismatches, printMismatchReport };

package/dist/index.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
-import { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, DEFAULT_RECENT_DAYS, MCP_DEFAULT_PORT, __commonJSMin, __require, __toESM } from "./pricing-fetcher-XdvIG0to.js";
+import { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, CLAUDE_PROJECTS_DIR_NAME, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __commonJSMin, __require, __toESM, require_usingCtx } from "./pricing-fetcher-CMyU5JUX.js";
 import { CostModes, SortOrders, dateSchema } from "./_types-Cr2YEzKm.js";
 import { calculateTotals, createTotalsObject, getTotalTokens } from "./calculate-cost-CoS7we68.js";
-import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, filterRecentBlocks, formatDateCompact, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, projectBlockUsage, uniq } from "./data-loader-BFS_JSqd.js";
-import { description, log, logger, name, version } from "./logger-CIYlc309.js";
-import { detectMismatches, printMismatchReport } from "./debug-DIfzQVQt.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-BI0xh4oM.js";
+import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, filterRecentBlocks, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, glob, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, projectBlockUsage, sortFilesByTimestamp, uniq, usageDataSchema } from "./data-loader-B_ymgjWR.js";
+import { description, log, logger, name, version } from "./logger-6I_KKR-u.js";
+import { detectMismatches, printMismatchReport } from "./debug-2jwq04IT.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-COnbPauf.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
 import process$1 from "node:process";
 import { createServer } from "node:http";
 import { Http2ServerRequest } from "node:http2";
@@ -1589,19 +1591,19 @@ var require_utils = __commonJSMin((exports, module) => {
 	function hyperlink(url, text) {
 		const OSC = "\x1B]";
 		const BEL = "\x07";
-		const SEP = ";";
+		const SEP$1 = ";";
 		return [
 			OSC,
 			"8",
-			SEP,
-			SEP,
+			SEP$1,
+			SEP$1,
 			url || text,
 			BEL,
 			text,
 			OSC,
 			"8",
-			SEP,
-			SEP,
+			SEP$1,
+			SEP$1,
 			BEL
 		].join("");
 	}
@@ -2558,8 +2560,8 @@ var require_cell = __commonJSMin((exports, module) => {
 		for (let i = 1; i < span; i++) ret += 1 + dimensionTable[startingIndex + i];
 		return ret;
 	}
-	function sumPlusOne(a, b) {
-		return a + b + 1;
+	function sumPlusOne(a$1, b) {
+		return a$1 + b + 1;
 	}
 	let CHAR_NAMES = [
 		"top",
@@ -2929,7 +2931,7 @@ function stringWidth(string, options = {}) {
 	return width;
 }
 var import_cli_table3 = __toESM(require_cli_table3(), 1);
-var import_picocolors$4 = __toESM(require_picocolors(), 1);
+var import_picocolors$5 = __toESM(require_picocolors(), 1);
 /**
 * Responsive table class that adapts column widths based on terminal size
 * Automatically adjusts formatting and layout for different screen sizes
@@ -3133,6 +3135,16 @@ function formatModelName(modelName) {
 	return modelName;
 }
 /**
+* Formats an array of model names for display as a comma-separated string
+* Removes duplicates and sorts alphabetically
+* @param models - Array of model names
+* @returns Formatted string with unique, sorted model names separated by commas
+*/
+function formatModelsDisplay(models) {
+	const uniqueModels = uniq(models.map(formatModelName));
+	return uniqueModels.sort().join(", ");
+}
+/**
 * Formats an array of model names for display with each model on a new line
 * Removes duplicates and sorts alphabetically
 * @param models - Array of model names
@@ -3155,11 +3167,727 @@ function pushBreakdownRows(table, breakdowns, extraColumns = 1, trailingColumns
 		const row = [`  └─ ${formatModelName(breakdown.modelName)}`];
 		for (let i = 0; i < extraColumns; i++) row.push("");
 		const totalTokens = breakdown.inputTokens + breakdown.outputTokens + breakdown.cacheCreationTokens + breakdown.cacheReadTokens;
-		row.push(import_picocolors$4.default.gray(formatNumber(breakdown.inputTokens)), import_picocolors$4.default.gray(formatNumber(breakdown.outputTokens)), import_picocolors$4.default.gray(formatNumber(breakdown.cacheCreationTokens)), import_picocolors$4.default.gray(formatNumber(breakdown.cacheReadTokens)), import_picocolors$4.default.gray(formatNumber(totalTokens)), import_picocolors$4.default.gray(formatCurrency(breakdown.cost)));
+		row.push(import_picocolors$5.default.gray(formatNumber(breakdown.inputTokens)), import_picocolors$5.default.gray(formatNumber(breakdown.outputTokens)), import_picocolors$5.default.gray(formatNumber(breakdown.cacheCreationTokens)), import_picocolors$5.default.gray(formatNumber(breakdown.cacheReadTokens)), import_picocolors$5.default.gray(formatNumber(totalTokens)), import_picocolors$5.default.gray(formatCurrency(breakdown.cost)));
 		for (let i = 0; i < trailingColumns; i++) row.push("");
 		table.push(row);
 	}
 }
+/** Options for {@linkcode delay}. */
+/**
+* Resolve a {@linkcode Promise} after a given amount of milliseconds.
+*
+* @throws {DOMException} If the optional signal is aborted before the delay
+* duration, and `signal.reason` is undefined.
+* @param ms Duration in milliseconds for how long the delay should last.
+* @param options Additional options.
+*
+* @example Basic usage
+* ```ts no-assert
+* import { delay } from "@std/async/delay";
+*
+* // ...
+* const delayedPromise = delay(100);
+* const result = await delayedPromise;
+* // ...
+* ```
+*
+* @example Disable persistence
+*
+* Setting `persistent` to `false` will allow the process to continue to run as
+* long as the timer exists.
+*
+* ```ts no-assert ignore
+* import { delay } from "@std/async/delay";
+*
+* // ...
+* await delay(100, { persistent: false });
+* // ...
+* ```
+*/ function delay(ms, options = {}) {
+	const { signal, persistent = true } = options;
+	if (signal?.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			clearTimeout(i);
+			reject(signal?.reason);
+		};
+		const done = () => {
+			signal?.removeEventListener("abort", abort);
+			resolve();
+		};
+		const i = setTimeout(done, ms);
+		signal?.addEventListener("abort", abort, { once: true });
+		if (persistent === false) try {
+			Deno.unrefTimer(i);
+		} catch (error) {
+			if (!(error instanceof ReferenceError)) throw error;
+			console.error("`persistent` option is only available in Deno");
+		}
+	});
+}
+const toZeroIfInfinity = (value) => Number.isFinite(value) ? value : 0;
+function parseNumber(milliseconds) {
+	return {
+		days: Math.trunc(milliseconds / 864e5),
+		hours: Math.trunc(milliseconds / 36e5 % 24),
+		minutes: Math.trunc(milliseconds / 6e4 % 60),
+		seconds: Math.trunc(milliseconds / 1e3 % 60),
+		milliseconds: Math.trunc(milliseconds % 1e3),
+		microseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e3) % 1e3),
+		nanoseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e6) % 1e3)
+	};
+}
+function parseBigint(milliseconds) {
+	return {
+		days: milliseconds / 86400000n,
+		hours: milliseconds / 3600000n % 24n,
+		minutes: milliseconds / 60000n % 60n,
+		seconds: milliseconds / 1000n % 60n,
+		milliseconds: milliseconds % 1000n,
+		microseconds: 0n,
+		nanoseconds: 0n
+	};
+}
+function parseMilliseconds(milliseconds) {
+	switch (typeof milliseconds) {
+		case "number": {
+			if (Number.isFinite(milliseconds)) return parseNumber(milliseconds);
+			break;
+		}
+		case "bigint": return parseBigint(milliseconds);
+	}
+	throw new TypeError("Expected a finite number or bigint");
+}
+const isZero = (value) => value === 0 || value === 0n;
+const pluralize = (word, count) => count === 1 || count === 1n ? word : `${word}s`;
+const SECOND_ROUNDING_EPSILON = 1e-7;
+const ONE_DAY_IN_MILLISECONDS = 24n * 60n * 60n * 1000n;
+function prettyMilliseconds(milliseconds, options) {
+	const isBigInt = typeof milliseconds === "bigint";
+	if (!isBigInt && !Number.isFinite(milliseconds)) throw new TypeError("Expected a finite number or bigint");
+	options = { ...options };
+	const sign = milliseconds < 0 ? "-" : "";
+	milliseconds = milliseconds < 0 ? -milliseconds : milliseconds;
+	if (options.colonNotation) {
+		options.compact = false;
+		options.formatSubMilliseconds = false;
+		options.separateMilliseconds = false;
+		options.verbose = false;
+	}
+	if (options.compact) {
+		options.unitCount = 1;
+		options.secondsDecimalDigits = 0;
+		options.millisecondsDecimalDigits = 0;
+	}
+	let result = [];
+	const floorDecimals = (value, decimalDigits) => {
+		const flooredInterimValue = Math.floor(value * 10 ** decimalDigits + SECOND_ROUNDING_EPSILON);
+		const flooredValue = Math.round(flooredInterimValue) / 10 ** decimalDigits;
+		return flooredValue.toFixed(decimalDigits);
+	};
+	const add = (value, long, short, valueString) => {
+		if ((result.length === 0 || !options.colonNotation) && isZero(value) && !(options.colonNotation && short === "m")) return;
+		valueString ??= String(value);
+		if (options.colonNotation) {
+			const wholeDigits = valueString.includes(".") ? valueString.split(".")[0].length : valueString.length;
+			const minLength = result.length > 0 ? 2 : 1;
+			valueString = "0".repeat(Math.max(0, minLength - wholeDigits)) + valueString;
+		} else valueString += options.verbose ? " " + pluralize(long, value) : short;
+		result.push(valueString);
+	};
+	const parsed = parseMilliseconds(milliseconds);
+	const days = BigInt(parsed.days);
+	if (options.hideYearAndDays) add(BigInt(days) * 24n + BigInt(parsed.hours), "hour", "h");
+	else {
+		if (options.hideYear) add(days, "day", "d");
+		else {
+			add(days / 365n, "year", "y");
+			add(days % 365n, "day", "d");
+		}
+		add(Number(parsed.hours), "hour", "h");
+	}
+	add(Number(parsed.minutes), "minute", "m");
+	if (!options.hideSeconds) if (options.separateMilliseconds || options.formatSubMilliseconds || !options.colonNotation && milliseconds < 1e3) {
+		const seconds = Number(parsed.seconds);
+		const milliseconds$1 = Number(parsed.milliseconds);
+		const microseconds = Number(parsed.microseconds);
+		const nanoseconds = Number(parsed.nanoseconds);
+		add(seconds, "second", "s");
+		if (options.formatSubMilliseconds) {
+			add(milliseconds$1, "millisecond", "ms");
+			add(microseconds, "microsecond", "µs");
+			add(nanoseconds, "nanosecond", "ns");
+		} else {
+			const millisecondsAndBelow = milliseconds$1 + microseconds / 1e3 + nanoseconds / 1e6;
+			const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
+			const roundedMilliseconds = millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
+			const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : roundedMilliseconds;
+			add(Number.parseFloat(millisecondsString), "millisecond", "ms", millisecondsString);
+		}
+	} else {
+		const seconds = (isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) / 1e3 % 60;
+		const secondsDecimalDigits = typeof options.secondsDecimalDigits === "number" ? options.secondsDecimalDigits : 1;
+		const secondsFixed = floorDecimals(seconds, secondsDecimalDigits);
+		const secondsString = options.keepDecimalsOnWholeSeconds ? secondsFixed : secondsFixed.replace(/\.0+$/, "");
+		add(Number.parseFloat(secondsString), "second", "s", secondsString);
+	}
+	if (result.length === 0) return sign + "0" + (options.verbose ? " milliseconds" : "ms");
+	const separator = options.colonNotation ? ":" : " ";
+	if (typeof options.unitCount === "number") result = result.slice(0, Math.max(options.unitCount, 1));
+	return sign + result.join(separator);
+}
+/**
+* Manages live monitoring of Claude usage with efficient data reloading
+*/
+var LiveMonitor = class {
+	config;
+	fetcher = null;
+	lastFileTimestamps = /* @__PURE__ */ new Map();
+	processedHashes = /* @__PURE__ */ new Set();
+	allEntries = [];
+	constructor(config) {
+		this.config = config;
+		if (config.mode !== "display") this.fetcher = new PricingFetcher();
+	}
+	/**
+	* Implements Disposable interface
+	*/
+	[Symbol.dispose]() {
+		this.fetcher?.[Symbol.dispose]();
+	}
+	/**
+	* Gets the current active session block with minimal file reading
+	* Only reads new or modified files since last check
+	*/
+	async getActiveBlock() {
+		const claudeDir = path.join(this.config.claudePath, CLAUDE_PROJECTS_DIR_NAME);
+		const files = await glob([USAGE_DATA_GLOB_PATTERN], {
+			cwd: claudeDir,
+			absolute: true
+		});
+		if (files.length === 0) return null;
+		const filesToRead = [];
+		for (const file of files) {
+			const timestamp = await getEarliestTimestamp(file);
+			const lastTimestamp = this.lastFileTimestamps.get(file);
+			if (timestamp != null && (lastTimestamp == null || timestamp.getTime() > lastTimestamp)) {
+				filesToRead.push(file);
+				this.lastFileTimestamps.set(file, timestamp.getTime());
+			}
+		}
+		if (filesToRead.length > 0) {
+			const sortedFiles = await sortFilesByTimestamp(filesToRead);
+			for (const file of sortedFiles) {
+				const content = await readFile(file, "utf-8");
+				const lines = content.trim().split("\n").filter((line) => line.length > 0);
+				for (const line of lines) try {
+					const parsed = JSON.parse(line);
+					const result = usageDataSchema.safeParse(parsed);
+					if (!result.success) continue;
+					const data = result.data;
+					const uniqueHash = createUniqueHash(data);
+					if (uniqueHash != null && this.processedHashes.has(uniqueHash)) continue;
+					if (uniqueHash != null) this.processedHashes.add(uniqueHash);
+					const costUSD = await (this.config.mode === "display" ? Promise.resolve(data.costUSD ?? 0) : calculateCostForEntry(data, this.config.mode, this.fetcher));
+					this.allEntries.push({
+						timestamp: new Date(data.timestamp),
+						usage: {
+							inputTokens: data.message.usage.input_tokens ?? 0,
+							outputTokens: data.message.usage.output_tokens ?? 0,
+							cacheCreationInputTokens: data.message.usage.cache_creation_input_tokens ?? 0,
+							cacheReadInputTokens: data.message.usage.cache_read_input_tokens ?? 0
+						},
+						costUSD,
+						model: data.message.model ?? "<synthetic>",
+						version: data.version
+					});
+				} catch {}
+			}
+		}
+		const blocks = identifySessionBlocks(this.allEntries, this.config.sessionDurationHours);
+		const sortedBlocks = this.config.order === "asc" ? blocks : blocks.reverse();
+		return sortedBlocks.find((block) => block.isActive) ?? null;
+	}
+	/**
+	* Clears all cached data to force a full reload
+	*/
+	clearCache() {
+		this.lastFileTimestamps.clear();
+		this.processedHashes.clear();
+		this.allEntries = [];
+	}
+};
+const isBrowser = globalThis.window?.document !== void 0;
+const isNode = globalThis.process?.versions?.node !== void 0;
+const isBun = globalThis.process?.versions?.bun !== void 0;
+const isDeno = globalThis.Deno?.version?.deno !== void 0;
+const isElectron = globalThis.process?.versions?.electron !== void 0;
+const isJsDom = globalThis.navigator?.userAgent?.includes("jsdom") === true;
+const isWebWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const isDedicatedWorker = typeof DedicatedWorkerGlobalScope !== "undefined" && globalThis instanceof DedicatedWorkerGlobalScope;
+const isSharedWorker = typeof SharedWorkerGlobalScope !== "undefined" && globalThis instanceof SharedWorkerGlobalScope;
+const isServiceWorker = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
+const platform = globalThis.navigator?.userAgentData?.platform;
+const isMacOs = platform === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
+const isWindows$1 = platform === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
+const isLinux = platform === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
+const isIos = platform === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
+const isAndroid = platform === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
+const ESC = "\x1B[";
+const SEP = ";";
+const isTerminalApp = !isBrowser && process$1.env.TERM_PROGRAM === "Apple_Terminal";
+const isWindows = !isBrowser && process$1.platform === "win32";
+const cwdFunction = isBrowser ? () => {
+	throw new Error("`process.cwd()` only works in Node.js, not the browser.");
+} : process$1.cwd;
+const cursorTo = (x, y) => {
+	if (typeof x !== "number") throw new TypeError("The `x` argument is required");
+	if (typeof y !== "number") return ESC + (x + 1) + "G";
+	return ESC + (y + 1) + SEP + (x + 1) + "H";
+};
+const cursorUp = (count = 1) => ESC + count + "A";
+const cursorDown = (count = 1) => ESC + count + "B";
+const cursorLeft = ESC + "G";
+const cursorSavePosition = isTerminalApp ? "\x1B7" : ESC + "s";
+const cursorRestorePosition = isTerminalApp ? "\x1B8" : ESC + "u";
+const cursorGetPosition = ESC + "6n";
+const cursorNextLine = ESC + "E";
+const cursorPrevLine = ESC + "F";
+const cursorHide = ESC + "?25l";
+const cursorShow = ESC + "?25h";
+const eraseEndLine = ESC + "K";
+const eraseStartLine = ESC + "1K";
+const eraseLine = ESC + "2K";
+const eraseDown = ESC + "J";
+const eraseUp = ESC + "1J";
+const eraseScreen = ESC + "2J";
+const scrollUp = ESC + "S";
+const scrollDown = ESC + "T";
+const clearScreen = "\x1Bc";
+const clearTerminal = isWindows ? `${eraseScreen}${ESC}0f` : `${eraseScreen}${ESC}3J${ESC}H`;
+const enterAlternativeScreen = ESC + "?1049h";
+const exitAlternativeScreen = ESC + "?1049l";
+/**
+* Terminal control sequences for live display updates
+*/
+const TERMINAL_CONTROL = {
+	HIDE_CURSOR: cursorHide,
+	SHOW_CURSOR: cursorShow,
+	CLEAR_SCREEN: clearScreen,
+	CLEAR_LINE: eraseLine,
+	MOVE_TO_TOP: cursorTo(0, 0),
+	MOVE_UP: (n) => cursorUp(n),
+	MOVE_DOWN: (n) => cursorDown(n),
+	MOVE_TO_COLUMN: (n) => cursorTo(n - 1, void 0)
+};
+/**
+* Manages terminal state for live updates
+*/
+var TerminalManager = class {
+	stream;
+	cursorHidden = false;
+	originalWrite;
+	constructor(stream = process$1.stdout) {
+		this.stream = stream;
+		this.originalWrite = stream.write.bind(stream);
+	}
+	/**
+	* Hides the terminal cursor
+	*/
+	hideCursor() {
+		if (!this.cursorHidden && this.stream.isTTY) {
+			this.stream.write(TERMINAL_CONTROL.HIDE_CURSOR);
+			this.cursorHidden = true;
+		}
+	}
+	/**
+	* Shows the terminal cursor
+	*/
+	showCursor() {
+		if (this.cursorHidden && this.stream.isTTY) {
+			this.stream.write(TERMINAL_CONTROL.SHOW_CURSOR);
+			this.cursorHidden = false;
+		}
+	}
+	/**
+	* Clears the entire screen and moves cursor to top
+	*/
+	clearScreen() {
+		if (this.stream.isTTY) {
+			this.stream.write(TERMINAL_CONTROL.CLEAR_SCREEN);
+			this.stream.write(TERMINAL_CONTROL.MOVE_TO_TOP);
+		}
+	}
+	/**
+	* Clears the current line
+	*/
+	clearLine() {
+		if (this.stream.isTTY) this.stream.write(TERMINAL_CONTROL.CLEAR_LINE);
+	}
+	/**
+	* Moves cursor up by n lines
+	*/
+	moveUp(lines) {
+		if (this.stream.isTTY && lines > 0) this.stream.write(TERMINAL_CONTROL.MOVE_UP(lines));
+	}
+	/**
+	* Moves cursor to beginning of line
+	*/
+	moveToLineStart() {
+		if (this.stream.isTTY) this.stream.write(TERMINAL_CONTROL.MOVE_TO_COLUMN(1));
+	}
+	/**
+	* Writes text to the stream
+	*/
+	write(text) {
+		this.stream.write(text);
+	}
+	/**
+	* Gets terminal width
+	*/
+	get width() {
+		return this.stream.columns || 80;
+	}
+	/**
+	* Gets terminal height
+	*/
+	get height() {
+		return this.stream.rows || 24;
+	}
+	/**
+	* Checks if the stream is a TTY
+	*/
+	get isTTY() {
+		return this.stream.isTTY ?? false;
+	}
+	/**
+	* Ensures cursor is shown on cleanup
+	*/
+	cleanup() {
+		this.showCursor();
+	}
+};
+/**
+* Creates a progress bar string
+* @param value - Current value
+* @param max - Maximum value
+* @param width - Width of the progress bar
+* @param options - Display options
+* @param options.showPercentage - Whether to show percentage
+* @param options.showValues - Whether to show current/max values
+* @param options.fillChar - Character for filled portion
+* @param options.emptyChar - Character for empty portion
+* @param options.leftBracket - Left bracket character
+* @param options.rightBracket - Right bracket character
+* @param options.colors - Color configuration
+* @param options.colors.low - Color for low percentage
+* @param options.colors.medium - Color for medium percentage
+* @param options.colors.high - Color for high percentage
+* @param options.colors.critical - Color for critical percentage
+* @returns Formatted progress bar string
+*/
+function createProgressBar(value, max, width, options = {}) {
+	const { showPercentage = true, showValues = false, fillChar = "█", emptyChar = "░", leftBracket = "[", rightBracket = "]", colors: colors$2 = {} } = options;
+	const percentage = max > 0 ? Math.min(100, value / max * 100) : 0;
+	const fillWidth = Math.round(percentage / 100 * width);
+	const emptyWidth = width - fillWidth;
+	let color = "";
+	if (colors$2.critical != null && percentage >= 90) color = colors$2.critical;
+	else if (colors$2.high != null && percentage >= 80) color = colors$2.high;
+	else if (colors$2.medium != null && percentage >= 50) color = colors$2.medium;
+	else if (colors$2.low != null) color = colors$2.low;
+	let bar = leftBracket;
+	if (color !== "") bar += color;
+	bar += fillChar.repeat(fillWidth);
+	bar += emptyChar.repeat(emptyWidth);
+	if (color !== "") bar += "\x1B[0m";
+	bar += rightBracket;
+	if (showPercentage) bar += ` ${percentage.toFixed(1)}%`;
+	if (showValues) bar += ` (${value}/${max})`;
+	return bar;
+}
+/**
+* Centers text within a given width
+* @param text - Text to center
+* @param width - Total width
+* @returns Centered text with padding
+*/
+function centerText(text, width) {
+	const textLength = stringWidth(text);
+	if (textLength >= width) return text;
+	const leftPadding = Math.floor((width - textLength) / 2);
+	const rightPadding = width - textLength - leftPadding;
+	return " ".repeat(leftPadding) + text + " ".repeat(rightPadding);
+}
+var import_picocolors$4 = __toESM(require_picocolors(), 1);
+var import_usingCtx = __toESM(require_usingCtx(), 1);
+/**
+* Format token counts with K suffix for display
+* @param num - Number of tokens
+* @returns Formatted string like "12.3k" or "999"
+*/
+function formatTokensShort(num) {
+	if (num >= 1e3) return `${(num / 1e3).toFixed(1)}k`;
+	return num.toString();
+}
+/**
+* Column layout constants for detail rows
+*/
+const DETAIL_COLUMN_WIDTHS = {
+	col1: 46,
+	col2: 37
+};
+/**
+* Starts live monitoring of the active session block
+*/
+async function startLiveMonitoring(config) {
+	try {
+		var _usingCtx = (0, import_usingCtx.default)();
+		const terminal = new TerminalManager();
+		const abortController = new AbortController();
+		const cleanup = () => {
+			abortController.abort();
+			terminal.cleanup();
+			terminal.clearScreen();
+			logger.info("Live monitoring stopped.");
+			if (process$1.exitCode == null) process$1.exit(0);
+		};
+		process$1.on("SIGINT", cleanup);
+		process$1.on("SIGTERM", cleanup);
+		terminal.hideCursor();
+		const monitor = _usingCtx.u(new LiveMonitor({
+			claudePath: config.claudePath,
+			sessionDurationHours: config.sessionDurationHours,
+			mode: config.mode,
+			order: config.order
+		}));
+		try {
+			while (!abortController.signal.aborted) {
+				const activeBlock = await monitor.getActiveBlock();
+				if (activeBlock == null) {
+					terminal.clearScreen();
+					terminal.write(import_picocolors$4.default.yellow("No active session block found. Waiting...\n"));
+					try {
+						await delay(config.refreshInterval, { signal: abortController.signal });
+					} catch (error) {
+						if ((error instanceof DOMException || error instanceof Error) && error.name === "AbortError") break;
+						throw error;
+					}
+					continue;
+				}
+				terminal.clearScreen();
+				renderLiveDisplay(terminal, activeBlock, config);
+				try {
+					await delay(config.refreshInterval, { signal: abortController.signal });
+				} catch (error) {
+					if ((error instanceof DOMException || error instanceof Error) && error.name === "AbortError") break;
+					throw error;
+				}
+			}
+		} catch (error) {
+			if ((error instanceof DOMException || error instanceof Error) && error.name === "AbortError") return;
+			terminal.clearScreen();
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			terminal.write(import_picocolors$4.default.red(`Error: ${errorMessage}\n`));
+			logger.error(`Live monitoring error: ${errorMessage}`);
+			try {
+				await delay(config.refreshInterval, { signal: abortController.signal });
+			} catch {}
+		}
+	} catch (_) {
+		_usingCtx.e = _;
+	} finally {
+		_usingCtx.d();
+	}
+}
+/**
+* Renders the live display for an active session block
+*/
+function renderLiveDisplay(terminal, block, config) {
+	const width = terminal.width;
+	const now = /* @__PURE__ */ new Date();
+	const totalTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+	const elapsed = (now.getTime() - block.startTime.getTime()) / (1e3 * 60);
+	const remaining = (block.endTime.getTime() - now.getTime()) / (1e3 * 60);
+	if (width < 60) {
+		renderCompactLiveDisplay(terminal, block, config, totalTokens, elapsed, remaining);
+		return;
+	}
+	terminal.clearScreen();
+	const boxWidth = Math.min(120, width - 2);
+	const boxMargin = Math.floor((width - boxWidth) / 2);
+	const marginStr = " ".repeat(boxMargin);
+	const labelWidth = 14;
+	const percentWidth = 7;
+	const shortLabelWidth = 20;
+	const barWidth = boxWidth - labelWidth - percentWidth - shortLabelWidth - 4;
+	const sessionDuration = elapsed + remaining;
+	const sessionPercent = elapsed / sessionDuration * 100;
+	const sessionProgressBar = createProgressBar(elapsed, sessionDuration, barWidth, {
+		showPercentage: false,
+		fillChar: import_picocolors$4.default.cyan("█"),
+		emptyChar: import_picocolors$4.default.gray("░"),
+		leftBracket: "[",
+		rightBracket: "]"
+	});
+	const startTime = block.startTime.toLocaleTimeString(void 0, {
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hour12: true
+	});
+	const endTime = block.endTime.toLocaleTimeString(void 0, {
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hour12: true
+	});
+	terminal.write(`${marginStr}┌${"─".repeat(boxWidth - 2)}┐\n`);
+	terminal.write(`${marginStr}│${import_picocolors$4.default.bold(centerText("CLAUDE CODE - LIVE TOKEN USAGE MONITOR", boxWidth - 2))}│\n`);
+	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
+	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
+	const sessionLabel = import_picocolors$4.default.bold("⏱️ SESSION");
+	const sessionLabelWidth = stringWidth(sessionLabel);
+	const sessionBarStr = `${sessionLabel}${"".padEnd(Math.max(0, labelWidth - sessionLabelWidth))} ${sessionProgressBar} ${sessionPercent.toFixed(1).padStart(6)}%`;
+	const sessionBarPadded = sessionBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(sessionBarStr)));
+	terminal.write(`${marginStr}│ ${sessionBarPadded}│\n`);
+	const col1 = `${import_picocolors$4.default.gray("Started:")} ${startTime}`;
+	const col2 = `${import_picocolors$4.default.gray("Elapsed:")} ${prettyMilliseconds(elapsed * 60 * 1e3, { compact: true })}`;
+	const col3 = `${import_picocolors$4.default.gray("Remaining:")} ${prettyMilliseconds(remaining * 60 * 1e3, { compact: true })} (${endTime})`;
+	const col1Visible = stringWidth(col1);
+	const col2Visible = stringWidth(col2);
+	const pad1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col1 - col1Visible));
+	const pad2 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col2 - col2Visible));
+	const sessionDetails = `   ${col1}${pad1}${col2}${pad2}${col3}`;
+	const sessionDetailsPadded = sessionDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(sessionDetails)));
+	terminal.write(`${marginStr}│ ${sessionDetailsPadded}│\n`);
+	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
+	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
+	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
+	const tokenPercent = config.tokenLimit != null && config.tokenLimit > 0 ? totalTokens / config.tokenLimit * 100 : 0;
+	let barColor = import_picocolors$4.default.green;
+	if (tokenPercent > 100) barColor = import_picocolors$4.default.red;
+	else if (tokenPercent > 80) barColor = import_picocolors$4.default.yellow;
+	const usageBar = config.tokenLimit != null && config.tokenLimit > 0 ? createProgressBar(totalTokens, config.tokenLimit, barWidth, {
+		showPercentage: false,
+		fillChar: barColor("█"),
+		emptyChar: import_picocolors$4.default.gray("░"),
+		leftBracket: "[",
+		rightBracket: "]"
+	}) : `[${import_picocolors$4.default.green("█".repeat(Math.floor(barWidth * .1)))}${import_picocolors$4.default.gray("░".repeat(barWidth - Math.floor(barWidth * .1)))}]`;
+	const burnRate = calculateBurnRate(block);
+	const rateIndicator = burnRate != null ? burnRate.tokensPerMinute > 1e3 ? import_picocolors$4.default.red("⚡ HIGH") : burnRate.tokensPerMinute > 500 ? import_picocolors$4.default.yellow("⚡ MODERATE") : import_picocolors$4.default.green("✓ NORMAL") : "";
+	const rateDisplay = burnRate != null ? `${import_picocolors$4.default.bold("Burn Rate:")} ${Math.round(burnRate.tokensPerMinute)} per min ${rateIndicator}` : `${import_picocolors$4.default.bold("Burn Rate:")} N/A`;
+	const usageLabel = import_picocolors$4.default.bold("🔥 USAGE");
+	const usageLabelWidth = stringWidth(usageLabel);
+	if (config.tokenLimit != null && config.tokenLimit > 0) {
+		const usageBarStr = `${usageLabel}${"".padEnd(Math.max(0, labelWidth - usageLabelWidth))} ${usageBar} ${tokenPercent.toFixed(1).padStart(6)}% (${formatTokensShort(totalTokens)}/${formatTokensShort(config.tokenLimit)})`;
+		const usageBarPadded = usageBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageBarStr)));
+		terminal.write(`${marginStr}│ ${usageBarPadded}│\n`);
+		const col1$1 = `${import_picocolors$4.default.gray("Tokens:")} ${formatNumber(totalTokens)} (${rateDisplay})`;
+		const col2$1 = `${import_picocolors$4.default.gray("Limit:")} ${formatNumber(config.tokenLimit)} tokens`;
+		const col3$1 = `${import_picocolors$4.default.gray("Cost:")} ${formatCurrency(block.costUSD)}`;
+		const col1Visible$1 = stringWidth(col1$1);
+		const col2Visible$1 = stringWidth(col2$1);
+		const pad1$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col1 - col1Visible$1));
+		const pad2$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col2 - col2Visible$1));
+		const usageDetails = `   ${col1$1}${pad1$1}${col2$1}${pad2$1}${col3$1}`;
+		const usageDetailsPadded = usageDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageDetails)));
+		terminal.write(`${marginStr}│ ${usageDetailsPadded}│\n`);
+	} else {
+		const usageBarStr = `${usageLabel}${"".padEnd(Math.max(0, labelWidth - usageLabelWidth))} ${usageBar} (${formatTokensShort(totalTokens)} tokens)`;
+		const usageBarPadded = usageBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageBarStr)));
+		terminal.write(`${marginStr}│ ${usageBarPadded}│\n`);
+		const col1$1 = `${import_picocolors$4.default.gray("Tokens:")} ${formatNumber(totalTokens)} (${rateDisplay})`;
+		const col3$1 = `${import_picocolors$4.default.gray("Cost:")} ${formatCurrency(block.costUSD)}`;
+		const col1Visible$1 = stringWidth(col1$1);
+		const pad1$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col1 - col1Visible$1));
+		const pad2$1 = " ".repeat(DETAIL_COLUMN_WIDTHS.col2);
+		const usageDetails = `   ${col1$1}${pad1$1}${pad2$1}${col3$1}`;
+		const usageDetailsPadded = usageDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageDetails)));
+		terminal.write(`${marginStr}│ ${usageDetailsPadded}│\n`);
+	}
+	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
+	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
+	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
+	const projection = projectBlockUsage(block);
+	if (projection != null) {
+		const projectedPercent = config.tokenLimit != null && config.tokenLimit > 0 ? projection.totalTokens / config.tokenLimit * 100 : 0;
+		let projBarColor = import_picocolors$4.default.green;
+		if (projectedPercent > 100) projBarColor = import_picocolors$4.default.red;
+		else if (projectedPercent > 80) projBarColor = import_picocolors$4.default.yellow;
+		const projectionBar = config.tokenLimit != null && config.tokenLimit > 0 ? createProgressBar(projection.totalTokens, config.tokenLimit, barWidth, {
+			showPercentage: false,
+			fillChar: projBarColor("█"),
+			emptyChar: import_picocolors$4.default.gray("░"),
+			leftBracket: "[",
+			rightBracket: "]"
+		}) : `[${import_picocolors$4.default.green("█".repeat(Math.floor(barWidth * .15)))}${import_picocolors$4.default.gray("░".repeat(barWidth - Math.floor(barWidth * .15)))}]`;
+		const limitStatus = config.tokenLimit != null && config.tokenLimit > 0 ? projectedPercent > 100 ? import_picocolors$4.default.red("❌ WILL EXCEED LIMIT") : projectedPercent > 80 ? import_picocolors$4.default.yellow("⚠️  APPROACHING LIMIT") : import_picocolors$4.default.green("✓ WITHIN LIMIT") : import_picocolors$4.default.green("✓ ON TRACK");
+		const projLabel = import_picocolors$4.default.bold("📈 PROJECTION");
+		const projLabelWidth = stringWidth(projLabel);
+		if (config.tokenLimit != null && config.tokenLimit > 0) {
+			const projBarStr = `${projLabel}${"".padEnd(Math.max(0, labelWidth - projLabelWidth))} ${projectionBar} ${projectedPercent.toFixed(1).padStart(6)}% (${formatTokensShort(projection.totalTokens)}/${formatTokensShort(config.tokenLimit)})`;
+			const projBarPadded = projBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projBarStr)));
+			terminal.write(`${marginStr}│ ${projBarPadded}│\n`);
+			const col1$1 = `${import_picocolors$4.default.gray("Status:")} ${limitStatus}`;
+			const col2$1 = `${import_picocolors$4.default.gray("Tokens:")} ${formatNumber(projection.totalTokens)}`;
+			const col3$1 = `${import_picocolors$4.default.gray("Cost:")} ${formatCurrency(projection.totalCost)}`;
+			const col1Visible$1 = stringWidth(col1$1);
+			const col2Visible$1 = stringWidth(col2$1);
+			const pad1$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col1 - col1Visible$1));
+			const pad2$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col2 - col2Visible$1));
+			const projDetails = `   ${col1$1}${pad1$1}${col2$1}${pad2$1}${col3$1}`;
+			const projDetailsPadded = projDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projDetails)));
+			terminal.write(`${marginStr}│ ${projDetailsPadded}│\n`);
+		} else {
+			const projBarStr = `${projLabel}${"".padEnd(Math.max(0, labelWidth - projLabelWidth))} ${projectionBar} (${formatTokensShort(projection.totalTokens)} tokens)`;
+			const projBarPadded = projBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projBarStr)));
+			terminal.write(`${marginStr}│ ${projBarPadded}│\n`);
+			const col1$1 = `${import_picocolors$4.default.gray("Status:")} ${limitStatus}`;
+			const col2$1 = `${import_picocolors$4.default.gray("Tokens:")} ${formatNumber(projection.totalTokens)}`;
+			const col3$1 = `${import_picocolors$4.default.gray("Cost:")} ${formatCurrency(projection.totalCost)}`;
+			const col1Visible$1 = stringWidth(col1$1);
+			const col2Visible$1 = stringWidth(col2$1);
+			const pad1$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col1 - col1Visible$1));
+			const pad2$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col2 - col2Visible$1));
+			const projDetails = `   ${col1$1}${pad1$1}${col2$1}${pad2$1}${col3$1}`;
+			const projDetailsPadded = projDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projDetails)));
+			terminal.write(`${marginStr}│ ${projDetailsPadded}│\n`);
+		}
+		terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
+	}
+	if (block.models.length > 0) {
+		terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
+		const modelsLine = `⚙️  Models: ${formatModelsDisplay(block.models)}`;
+		const modelsLinePadded = modelsLine + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(modelsLine)));
+		terminal.write(`${marginStr}│ ${modelsLinePadded}│\n`);
+	}
+	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
+	const refreshText = `↻ Refreshing every ${config.refreshInterval / 1e3}s  •  Press Ctrl+C to stop`;
+	terminal.write(`${marginStr}│${import_picocolors$4.default.gray(centerText(refreshText, boxWidth - 2))}│\n`);
+	terminal.write(`${marginStr}└${"─".repeat(boxWidth - 2)}┘\n`);
+}
+/**
+* Renders a compact live display for narrow terminals
+*/
+function renderCompactLiveDisplay(terminal, block, config, totalTokens, elapsed, remaining) {
+	const width = terminal.width;
+	terminal.write(`${import_picocolors$4.default.bold(centerText("LIVE MONITOR", width))}\n`);
+	terminal.write(`${"─".repeat(width)}\n`);
+	const sessionPercent = elapsed / (elapsed + remaining) * 100;
+	terminal.write(`Session: ${sessionPercent.toFixed(1)}% (${Math.floor(elapsed / 60)}h ${Math.floor(elapsed % 60)}m)\n`);
+	if (config.tokenLimit != null && config.tokenLimit > 0) {
+		const tokenPercent = totalTokens / config.tokenLimit * 100;
+		const status = tokenPercent > 100 ? import_picocolors$4.default.red("OVER") : tokenPercent > 80 ? import_picocolors$4.default.yellow("WARN") : import_picocolors$4.default.green("OK");
+		terminal.write(`Tokens: ${formatNumber(totalTokens)}/${formatNumber(config.tokenLimit)} ${status}\n`);
+	} else terminal.write(`Tokens: ${formatNumber(totalTokens)}\n`);
+	terminal.write(`Cost: ${formatCurrency(block.costUSD)}\n`);
+	const burnRate = calculateBurnRate(block);
+	if (burnRate != null) terminal.write(`Rate: ${formatNumber(burnRate.tokensPerMinute)}/min\n`);
+	terminal.write(`${"─".repeat(width)}\n`);
+	terminal.write(import_picocolors$4.default.gray(`Refresh: ${config.refreshInterval / 1e3}s | Ctrl+C: stop\n`));
+}
 var import_picocolors$3 = __toESM(require_picocolors(), 1);
 /**
 * Formats the time display for a session block
@@ -3241,13 +3969,23 @@ const blocksCommand = define({
 		tokenLimit: {
 			type: "string",
 			short: "t",
-			description: "Token limit for quota warnings (e.g., 500000 or \"max\" for highest previous block)"
+			description: "Token limit for quota warnings (e.g., 500000 or \"max\")"
 		},
 		sessionLength: {
 			type: "number",
 			short: "l",
 			description: `Session block duration in hours (default: ${DEFAULT_SESSION_DURATION_HOURS})`,
 			default: DEFAULT_SESSION_DURATION_HOURS
+		},
+		live: {
+			type: "boolean",
+			description: "Live monitoring mode with real-time updates",
+			default: false
+		},
+		refreshInterval: {
+			type: "number",
+			description: `Refresh interval in seconds for live mode (default: ${DEFAULT_REFRESH_INTERVAL_SECONDS})`,
+			default: DEFAULT_REFRESH_INTERVAL_SECONDS
 		}
 	},
 	toKebab: true,
@@ -3290,6 +4028,25 @@ const blocksCommand = define({
 				process$1.exit(0);
 			}
 		}
+		if (ctx.values.live && !ctx.values.json) {
+			if (!ctx.values.active) logger.info("Live mode automatically shows only active blocks.");
+			let tokenLimitValue = ctx.values.tokenLimit;
+			if (tokenLimitValue == null || tokenLimitValue === "") {
+				tokenLimitValue = "max";
+				if (maxTokensFromAll > 0) logger.info(`No token limit specified, using max from previous sessions: ${formatNumber(maxTokensFromAll)}`);
+			}
+			const refreshInterval = Math.max(MIN_REFRESH_INTERVAL_SECONDS, Math.min(MAX_REFRESH_INTERVAL_SECONDS, ctx.values.refreshInterval));
+			if (refreshInterval !== ctx.values.refreshInterval) logger.warn(`Refresh interval adjusted to ${refreshInterval} seconds (valid range: ${MIN_REFRESH_INTERVAL_SECONDS}-${MAX_REFRESH_INTERVAL_SECONDS})`);
+			await startLiveMonitoring({
+				claudePath: getDefaultClaudePath(),
+				tokenLimit: parseTokenLimit(tokenLimitValue, maxTokensFromAll),
+				refreshInterval: refreshInterval * 1e3,
+				sessionDurationHours: ctx.values.sessionLength,
+				mode: ctx.values.mode,
+				order: ctx.values.order
+			});
+			return;
+		}
 		if (ctx.values.json) {
 			const jsonOutput = { blocks: blocks.map((block) => {
 				const burnRate = block.isActive ? calculateBurnRate(block) : null;

package/dist/{logger-CIYlc309.js → logger-6I_KKR-u.js}

@@ -951,7 +951,7 @@ function _getDefaultLogLevel() {
 }
 const consola = createConsola$1();
 var name = "ccusage";
-var version = "14.1.2";
+var version = "15.0.0";
 var description = "Usage analysis tool for Claude Code";
 /**
 * Application logger instance with package name tag

package/dist/logger.js

@@ -1,2 +1,2 @@
-import { log, logger } from "./logger-CIYlc309.js";
+import { log, logger } from "./logger-6I_KKR-u.js";
 export { log, logger };

package/dist/{mcp-BI0xh4oM.js → mcp-COnbPauf.js}

@@ -1,7 +1,7 @@
-import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-XdvIG0to.js";
+import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-CMyU5JUX.js";
 import { ZodFirstPartyTypeKind, ZodOptional, ZodType, arrayType, booleanType, dateSchema, discriminatedUnionType, enumType, literalType, numberType, objectType, optionalType, recordType, stringType, unionType, unknownType } from "./_types-Cr2YEzKm.js";
-import { getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-BFS_JSqd.js";
-import { name, version } from "./logger-CIYlc309.js";
+import { getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-B_ymgjWR.js";
+import { name, version } from "./logger-6I_KKR-u.js";
 import process from "node:process";
 const LATEST_PROTOCOL_VERSION = "2025-03-26";
 const SUPPORTED_PROTOCOL_VERSIONS = [

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import "./pricing-fetcher-CXnYw4TA.js";
-import { LoadOptions } from "./data-loader-C1n0ww95.js";
+import { LoadOptions } from "./data-loader-Bll0wMdK.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Hono } from "hono/tiny";
 

package/dist/mcp.js

@@ -1,6 +1,6 @@
-import "./pricing-fetcher-XdvIG0to.js";
+import "./pricing-fetcher-CMyU5JUX.js";
 import "./_types-Cr2YEzKm.js";
-import "./data-loader-BFS_JSqd.js";
-import "./logger-CIYlc309.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-BI0xh4oM.js";
+import "./data-loader-B_ymgjWR.js";
+import "./logger-6I_KKR-u.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-COnbPauf.js";
 export { createMcpHttpApp, createMcpServer, startMcpServerStdio };

package/dist/{pricing-fetcher-XdvIG0to.js → pricing-fetcher-CMyU5JUX.js}

@@ -1,5 +1,5 @@
 import { modelPricingSchema } from "./_types-Cr2YEzKm.js";
-import { logger } from "./logger-CIYlc309.js";
+import { logger } from "./logger-6I_KKR-u.js";
 import { createRequire } from "node:module";
 import F, { homedir } from "node:os";
 import path from "node:path";
@@ -105,6 +105,21 @@ const USAGE_DATA_GLOB_PATTERN = "**/*.jsonl";
 * Used when no port is specified for MCP server communication
 */
 const MCP_DEFAULT_PORT = 8080;
+/**
+* Default refresh interval in seconds for live monitoring mode
+* Used in blocks command for real-time updates
+*/
+const DEFAULT_REFRESH_INTERVAL_SECONDS = 1;
+/**
+* Minimum refresh interval in seconds for live monitoring mode
+* Prevents too-frequent updates that could impact performance
+*/
+const MIN_REFRESH_INTERVAL_SECONDS = 1;
+/**
+* Maximum refresh interval in seconds for live monitoring mode
+* Prevents too-slow updates that reduce monitoring effectiveness
+*/
+const MAX_REFRESH_INTERVAL_SECONDS = 60;
 var require_usingCtx = __commonJSMin((exports, module) => {
 	function _usingCtx() {
 		var r = "function" == typeof SuppressedError ? SuppressedError : function(r$1, e$1) {
@@ -389,4 +404,4 @@ var PricingFetcher = class {
 		return cost;
 	}
 };
-export { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, MCP_DEFAULT_PORT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, require_usingCtx };
+export { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, require_usingCtx };

package/dist/pricing-fetcher.js

@@ -1,4 +1,4 @@
-import { PricingFetcher } from "./pricing-fetcher-XdvIG0to.js";
+import { PricingFetcher } from "./pricing-fetcher-CMyU5JUX.js";
 import "./_types-Cr2YEzKm.js";
-import "./logger-CIYlc309.js";
+import "./logger-6I_KKR-u.js";
 export { PricingFetcher };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccusage",
   "type": "module",
-  "version": "14.1.2",
+  "version": "15.0.0",
   "description": "Usage analysis tool for Claude Code",
   "author": "ryoppippi",
   "license": "MIT",