ccusage 15.7.1 → 15.9.0

package/README.md

@@ -55,6 +55,7 @@ ccusage daily    # Daily token usage and costs
 ccusage monthly  # Monthly aggregated report
 ccusage session  # Usage by conversation session
 ccusage blocks   # 5-hour billing windows
+ccusage statusline  # Compact status line for hooks (Beta)
 
 # Live monitoring
 ccusage blocks --live  # Real-time usage dashboard
@@ -79,6 +80,7 @@ ccusage daily --instances --project myproject --json  # Combined usage
 - 💬 **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`
+- 🚀 **Statusline Integration**: Compact usage display for Claude Code status bar hooks (Beta)
 - 🤖 **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`

package/dist/{_types-ed8-0BH6.js → _types-B-1t4mxD.js}

@@ -3610,4 +3610,21 @@ const modelPricingSchema = objectType({
 	cache_creation_input_token_cost: numberType().optional(),
 	cache_read_input_token_cost: numberType().optional()
 });
-export { CostModes, SortOrders, ZodFirstPartyTypeKind, ZodOptional, ZodType, activityDateSchema, arrayType, booleanType, createBucket, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, createWeeklyDate, dailyDateSchema, discriminatedUnionType, enumType, filterDateSchema, isoTimestampSchema, literalType, messageIdSchema, modelNameSchema, modelPricingSchema, monthlyDateSchema, numberType, objectType, optionalType, projectPathSchema, recordType, requestIdSchema, sessionIdSchema, stringType, unionType, unknownType, versionSchema, weeklyDateSchema };
+/**
+* Zod schema for Claude Code statusline hook JSON data
+*/
+const statuslineHookJsonSchema = objectType({
+	session_id: stringType(),
+	transcript_path: stringType(),
+	cwd: stringType(),
+	model: objectType({
+		id: stringType(),
+		display_name: stringType()
+	}),
+	workspace: objectType({
+		current_dir: stringType(),
+		project_dir: stringType()
+	}),
+	version: stringType().optional()
+});
+export { CostModes, SortOrders, ZodFirstPartyTypeKind, ZodOptional, ZodType, activityDateSchema, arrayType, booleanType, createBucket, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, createWeeklyDate, dailyDateSchema, discriminatedUnionType, enumType, filterDateSchema, isoTimestampSchema, literalType, messageIdSchema, modelNameSchema, modelPricingSchema, monthlyDateSchema, numberType, objectType, optionalType, projectPathSchema, recordType, requestIdSchema, sessionIdSchema, statuslineHookJsonSchema, stringType, unionType, unknownType, versionSchema, weeklyDateSchema };

package/dist/calculate-cost.d.ts

@@ -1,5 +1,5 @@
-import "./pricing-fetcher-AYfCy7g-.js";
-import { DailyUsage, MonthlyUsage, SessionUsage, WeeklyUsage } from "./data-loader-De3CFZ54.js";
+import "./pricing-fetcher-C9P2YKDv.js";
+import { DailyUsage, MonthlyUsage, SessionUsage, WeeklyUsage } from "./data-loader-PvTcFbip.js";
 
 //#region src/_token-utils.d.ts
 

package/dist/calculate-cost.js

@@ -1,4 +1,4 @@
 import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
-import "./_types-ed8-0BH6.js";
+import "./_types-B-1t4mxD.js";
 import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
 export { calculateTotals, createTotalsObject, getTotalTokens };

package/dist/{data-loader-CclfHqXI.js → data-loader-CKAeM9ir.js}

@@ -1,7 +1,7 @@
-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, isFailure, isPromise, require_usingCtx } from "./pricing-fetcher-DWqNGcYq.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, isFailure, isPromise, require_usingCtx } from "./pricing-fetcher-S0o3dB03.js";
 import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
-import { activityDateSchema, arrayType, booleanType, createBucket, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, createWeeklyDate, dailyDateSchema, isoTimestampSchema, messageIdSchema, modelNameSchema, monthlyDateSchema, numberType, objectType, projectPathSchema, requestIdSchema, sessionIdSchema, stringType, unionType, versionSchema, weeklyDateSchema } from "./_types-ed8-0BH6.js";
-import { logger } from "./logger-D8Vy4evt.js";
+import { activityDateSchema, arrayType, booleanType, createBucket, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, createWeeklyDate, dailyDateSchema, isoTimestampSchema, messageIdSchema, modelNameSchema, monthlyDateSchema, numberType, objectType, projectPathSchema, requestIdSchema, sessionIdSchema, stringType, unionType, versionSchema, weeklyDateSchema } from "./_types-B-1t4mxD.js";
+import { logger } from "./logger-DxuNm8GV.js";
 import a, { readFile } from "node:fs/promises";
 import path, { posix } from "node:path";
 import process$1 from "node:process";
@@ -3347,6 +3347,8 @@ function extractProjectFromPath(jsonlPath) {
 * Zod schema for validating Claude usage data from JSONL files
 */
 const usageDataSchema = objectType({
+	cwd: stringType().optional(),
+	sessionId: sessionIdSchema.optional(),
 	timestamp: isoTimestampSchema,
 	version: versionSchema.optional(),
 	message: objectType({
@@ -3951,6 +3953,49 @@ async function loadWeeklyUsageData(options) {
 		...rest
 	})));
 }
+/**
+* Load usage data for a specific session by sessionId
+* Searches for a JSONL file named {sessionId}.jsonl in all Claude project directories
+* @param sessionId - The session ID to load data for (matches the JSONL filename)
+* @param options - Options for loading data
+* @param options.mode - Cost calculation mode (auto, calculate, display)
+* @param options.offline - Whether to use offline pricing data
+* @returns Usage data for the specific session or null if not found
+*/
+async function loadSessionUsageById(sessionId, options) {
+	try {
+		var _usingCtx4 = (0, import_usingCtx.default)();
+		const claudePaths = getClaudePaths();
+		const patterns = claudePaths.map((p) => path.join(p, "projects", "**", `${sessionId}.jsonl`));
+		const jsonlFiles = await glob(patterns);
+		if (jsonlFiles.length === 0) return null;
+		const file = jsonlFiles[0];
+		if (file == null) return null;
+		const content = await readFile(file, "utf-8");
+		const lines = content.trim().split("\n").filter((line) => line.length > 0);
+		const mode = options?.mode ?? "auto";
+		const fetcher = _usingCtx4.u(mode === "display" ? null : new PricingFetcher(options?.offline));
+		const entries = [];
+		let totalCost = 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 cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+			totalCost += cost;
+			entries.push(data);
+		} catch {}
+		return {
+			totalCost,
+			entries
+		};
+	} catch (_) {
+		_usingCtx4.e = _;
+	} finally {
+		_usingCtx4.d();
+	}
+}
 async function loadBucketUsageData(groupingFn, options) {
 	const dailyData = await loadDailyUsageData(options);
 	const needsProjectGrouping = options?.groupByProject === true || options?.project != null;
@@ -4002,7 +4047,7 @@ async function loadBucketUsageData(groupingFn, options) {
 */
 async function loadSessionBlockData(options) {
 	try {
-		var _usingCtx4 = (0, import_usingCtx.default)();
+		var _usingCtx5 = (0, import_usingCtx.default)();
 		const claudePaths = toArray(options?.claudePath ?? getClaudePaths());
 		const allFiles = [];
 		for (const claudePath of claudePaths) {
@@ -4017,7 +4062,7 @@ async function loadSessionBlockData(options) {
 		const blocksFilteredFiles = filterByProject(allFiles, (filePath) => extractProjectFromPath(filePath), options?.project);
 		const sortedFiles = await sortFilesByTimestamp(blocksFilteredFiles);
 		const mode = options?.mode ?? "auto";
-		const fetcher = _usingCtx4.u(mode === "display" ? null : new PricingFetcher(options?.offline));
+		const fetcher = _usingCtx5.u(mode === "display" ? null : new PricingFetcher(options?.offline));
 		const processedHashes = new Set();
 		const allEntries = [];
 		for (const file of sortedFiles) {
@@ -4059,9 +4104,9 @@ async function loadSessionBlockData(options) {
 		}) : blocks;
 		return sortByDate(dateFiltered, (block) => block.startTime, options?.order);
 	} catch (_) {
-		_usingCtx4.e = _;
+		_usingCtx5.e = _;
 	} finally {
-		_usingCtx4.d();
+		_usingCtx5.d();
 	}
 }
-export { DEFAULT_SESSION_DURATION_HOURS, bucketUsageSchema, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, filterRecentBlocks, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, glob, globUsageFiles, identifySessionBlocks, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, uniq, unwrap, usageDataSchema, weeklyUsageSchema };
+export { DEFAULT_SESSION_DURATION_HOURS, bucketUsageSchema, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, filterRecentBlocks, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, glob, globUsageFiles, identifySessionBlocks, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, uniq, unwrap, usageDataSchema, weeklyUsageSchema };

package/dist/{data-loader-De3CFZ54.d.ts → data-loader-PvTcFbip.d.ts}

@@ -1,4 +1,4 @@
-import { Bucket, CostMode, PricingFetcher$1 as PricingFetcher, SortOrder, TupleToUnion } from "./pricing-fetcher-AYfCy7g-.js";
+import { Bucket, CostMode, PricingFetcher$1 as PricingFetcher, SortOrder, TupleToUnion } from "./pricing-fetcher-C9P2YKDv.js";
 import { z } from "zod";
 
 //#region src/_consts.d.ts
@@ -72,6 +72,8 @@ declare function extractProjectFromPath(jsonlPath: string): string;
  * Zod schema for validating Claude usage data from JSONL files
  */
 declare const usageDataSchema: z.ZodObject<{
+  cwd: z.ZodOptional<z.ZodString>;
+  sessionId: z.ZodOptional<z.ZodBranded<z.ZodString, "SessionId">>;
   timestamp: z.ZodBranded<z.ZodString, "ISOTimestamp">;
   version: z.ZodOptional<z.ZodBranded<z.ZodString, "Version">>;
   message: z.ZodObject<{
@@ -129,6 +131,8 @@ declare const usageDataSchema: z.ZodObject<{
   requestId: z.ZodOptional<z.ZodBranded<z.ZodString, "RequestId">>;
   isApiErrorMessage: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+  cwd?: string | undefined;
+  sessionId?: (string & z.BRAND<"SessionId">) | undefined;
   timestamp: string & z.BRAND<"ISOTimestamp">;
   version?: (string & z.BRAND<"Version">) | undefined;
   message: {
@@ -148,6 +152,8 @@ declare const usageDataSchema: z.ZodObject<{
   requestId?: (string & z.BRAND<"RequestId">) | undefined;
   isApiErrorMessage?: boolean | undefined;
 }, {
+  cwd?: string | undefined;
+  sessionId?: string | undefined;
   timestamp: string;
   version?: string | undefined;
   message: {
@@ -673,6 +679,22 @@ declare function loadSessionData(options?: LoadOptions): Promise<SessionUsage[]>
  */
 declare function loadMonthlyUsageData(options?: LoadOptions): Promise<MonthlyUsage[]>;
 declare function loadWeeklyUsageData(options?: LoadOptions): Promise<WeeklyUsage[]>;
+/**
+ * Load usage data for a specific session by sessionId
+ * Searches for a JSONL file named {sessionId}.jsonl in all Claude project directories
+ * @param sessionId - The session ID to load data for (matches the JSONL filename)
+ * @param options - Options for loading data
+ * @param options.mode - Cost calculation mode (auto, calculate, display)
+ * @param options.offline - Whether to use offline pricing data
+ * @returns Usage data for the specific session or null if not found
+ */
+declare function loadSessionUsageById(sessionId: string, options?: {
+  mode?: CostMode;
+  offline?: boolean;
+}): Promise<{
+  totalCost: number;
+  entries: UsageData[];
+} | null>;
 declare function loadBucketUsageData(groupingFn: (data: DailyUsage) => Bucket, options?: LoadOptions): Promise<BucketUsage[]>;
 /**
  * Loads usage data and organizes it into session blocks (typically 5-hour billing periods)
@@ -682,4 +704,4 @@ declare function loadBucketUsageData(groupingFn: (data: DailyUsage) => Bucket, o
  */
 declare function loadSessionBlockData(options?: LoadOptions): Promise<SessionBlock[]>;
 //#endregion
-export { BucketUsage, DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, WeeklyUsage, bucketUsageSchema as bucketUsageSchema$1, calculateCostForEntry as calculateCostForEntry$1, createUniqueHash as createUniqueHash$1, dailyUsageSchema as dailyUsageSchema$1, extractProjectFromPath as extractProjectFromPath$1, formatDate as formatDate$1, formatDateCompact as formatDateCompact$1, getClaudePaths as getClaudePaths$1, getEarliestTimestamp as getEarliestTimestamp$1, getUsageLimitResetTime as getUsageLimitResetTime$1, globUsageFiles as globUsageFiles$1, loadBucketUsageData as loadBucketUsageData$1, loadDailyUsageData as loadDailyUsageData$1, loadMonthlyUsageData as loadMonthlyUsageData$1, loadSessionBlockData as loadSessionBlockData$1, loadSessionData as loadSessionData$1, loadWeeklyUsageData as loadWeeklyUsageData$1, modelBreakdownSchema as modelBreakdownSchema$1, monthlyUsageSchema as monthlyUsageSchema$1, sessionUsageSchema as sessionUsageSchema$1, sortFilesByTimestamp as sortFilesByTimestamp$1, usageDataSchema as usageDataSchema$1, weeklyUsageSchema as weeklyUsageSchema$1 };
+export { BucketUsage, DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, WeeklyUsage, bucketUsageSchema as bucketUsageSchema$1, calculateCostForEntry as calculateCostForEntry$1, createUniqueHash as createUniqueHash$1, dailyUsageSchema as dailyUsageSchema$1, extractProjectFromPath as extractProjectFromPath$1, formatDate as formatDate$1, formatDateCompact as formatDateCompact$1, getClaudePaths as getClaudePaths$1, getEarliestTimestamp as getEarliestTimestamp$1, getUsageLimitResetTime as getUsageLimitResetTime$1, globUsageFiles as globUsageFiles$1, loadBucketUsageData as loadBucketUsageData$1, loadDailyUsageData as loadDailyUsageData$1, loadMonthlyUsageData as loadMonthlyUsageData$1, loadSessionBlockData as loadSessionBlockData$1, loadSessionData as loadSessionData$1, loadSessionUsageById as loadSessionUsageById$1, loadWeeklyUsageData as loadWeeklyUsageData$1, modelBreakdownSchema as modelBreakdownSchema$1, monthlyUsageSchema as monthlyUsageSchema$1, sessionUsageSchema as sessionUsageSchema$1, sortFilesByTimestamp as sortFilesByTimestamp$1, usageDataSchema as usageDataSchema$1, weeklyUsageSchema as weeklyUsageSchema$1 };

package/dist/data-loader.d.ts

@@ -1,3 +1,3 @@
-import "./pricing-fetcher-AYfCy7g-.js";
-import { BucketUsage, DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, WeeklyUsage, bucketUsageSchema$1 as bucketUsageSchema, calculateCostForEntry$1 as calculateCostForEntry, createUniqueHash$1 as createUniqueHash, dailyUsageSchema$1 as dailyUsageSchema, extractProjectFromPath$1 as extractProjectFromPath, formatDate$1 as formatDate, formatDateCompact$1 as formatDateCompact, getClaudePaths$1 as getClaudePaths, getEarliestTimestamp$1 as getEarliestTimestamp, getUsageLimitResetTime$1 as getUsageLimitResetTime, globUsageFiles$1 as globUsageFiles, loadBucketUsageData$1 as loadBucketUsageData, loadDailyUsageData$1 as loadDailyUsageData, loadMonthlyUsageData$1 as loadMonthlyUsageData, loadSessionBlockData$1 as loadSessionBlockData, loadSessionData$1 as loadSessionData, loadWeeklyUsageData$1 as loadWeeklyUsageData, modelBreakdownSchema$1 as modelBreakdownSchema, monthlyUsageSchema$1 as monthlyUsageSchema, sessionUsageSchema$1 as sessionUsageSchema, sortFilesByTimestamp$1 as sortFilesByTimestamp, usageDataSchema$1 as usageDataSchema, weeklyUsageSchema$1 as weeklyUsageSchema } from "./data-loader-De3CFZ54.js";
-export { BucketUsage, DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, WeeklyUsage, bucketUsageSchema, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema, weeklyUsageSchema };
+import "./pricing-fetcher-C9P2YKDv.js";
+import { BucketUsage, DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, WeeklyUsage, bucketUsageSchema$1 as bucketUsageSchema, calculateCostForEntry$1 as calculateCostForEntry, createUniqueHash$1 as createUniqueHash, dailyUsageSchema$1 as dailyUsageSchema, extractProjectFromPath$1 as extractProjectFromPath, formatDate$1 as formatDate, formatDateCompact$1 as formatDateCompact, getClaudePaths$1 as getClaudePaths, getEarliestTimestamp$1 as getEarliestTimestamp, getUsageLimitResetTime$1 as getUsageLimitResetTime, globUsageFiles$1 as globUsageFiles, loadBucketUsageData$1 as loadBucketUsageData, loadDailyUsageData$1 as loadDailyUsageData, loadMonthlyUsageData$1 as loadMonthlyUsageData, loadSessionBlockData$1 as loadSessionBlockData, loadSessionData$1 as loadSessionData, loadSessionUsageById$1 as loadSessionUsageById, loadWeeklyUsageData$1 as loadWeeklyUsageData, modelBreakdownSchema$1 as modelBreakdownSchema, monthlyUsageSchema$1 as monthlyUsageSchema, sessionUsageSchema$1 as sessionUsageSchema, sortFilesByTimestamp$1 as sortFilesByTimestamp, usageDataSchema$1 as usageDataSchema, weeklyUsageSchema$1 as weeklyUsageSchema } from "./data-loader-PvTcFbip.js";
+export { BucketUsage, DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, WeeklyUsage, bucketUsageSchema, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema, weeklyUsageSchema };

package/dist/data-loader.js

@@ -1,6 +1,6 @@
-import "./pricing-fetcher-DWqNGcYq.js";
+import "./pricing-fetcher-S0o3dB03.js";
 import "./_token-utils-WjkbrjKv.js";
-import "./_types-ed8-0BH6.js";
-import { bucketUsageSchema, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema, weeklyUsageSchema } from "./data-loader-CclfHqXI.js";
-import "./logger-D8Vy4evt.js";
-export { bucketUsageSchema, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema, weeklyUsageSchema };
+import "./_types-B-1t4mxD.js";
+import { bucketUsageSchema, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema, weeklyUsageSchema } from "./data-loader-CKAeM9ir.js";
+import "./logger-DxuNm8GV.js";
+export { bucketUsageSchema, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema, weeklyUsageSchema };

package/dist/{debug-B3DW8asF.js → debug-DMwiBRRn.js}

@@ -1,6 +1,6 @@
-import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-DWqNGcYq.js";
-import { getClaudePaths, glob, unwrap, usageDataSchema } from "./data-loader-CclfHqXI.js";
-import { logger } from "./logger-D8Vy4evt.js";
+import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-S0o3dB03.js";
+import { getClaudePaths, glob, unwrap, usageDataSchema } from "./data-loader-CKAeM9ir.js";
+import { logger } from "./logger-DxuNm8GV.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 var import_usingCtx = __toESM(require_usingCtx(), 1);

package/dist/debug.js

@@ -1,7 +1,7 @@
-import "./pricing-fetcher-DWqNGcYq.js";
+import "./pricing-fetcher-S0o3dB03.js";
 import "./_token-utils-WjkbrjKv.js";
-import "./_types-ed8-0BH6.js";
-import "./data-loader-CclfHqXI.js";
-import "./logger-D8Vy4evt.js";
-import { detectMismatches, printMismatchReport } from "./debug-B3DW8asF.js";
+import "./_types-B-1t4mxD.js";
+import "./data-loader-CKAeM9ir.js";
+import "./logger-DxuNm8GV.js";
+import { detectMismatches, printMismatchReport } from "./debug-DMwiBRRn.js";
 export { detectMismatches, printMismatchReport };

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PROJECT_ALIASES_ENV, PricingFetcher, WEEK_DAYS, __commonJSMin, __require, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-DWqNGcYq.js";
+import { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PROJECT_ALIASES_ENV, PricingFetcher, WEEK_DAYS, __commonJSMin, __require, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-S0o3dB03.js";
 import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
-import { CostModes, SortOrders, filterDateSchema } from "./_types-ed8-0BH6.js";
+import { CostModes, SortOrders, filterDateSchema, statuslineHookJsonSchema } from "./_types-B-1t4mxD.js";
 import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
-import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, filterRecentBlocks, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadWeeklyUsageData, projectBlockUsage, sortFilesByTimestamp, uniq, usageDataSchema } from "./data-loader-CclfHqXI.js";
-import { description, log, logger, name, version } from "./logger-D8Vy4evt.js";
-import { detectMismatches, printMismatchReport } from "./debug-B3DW8asF.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-DCAyJs6a.js";
+import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, filterRecentBlocks, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, projectBlockUsage, sortFilesByTimestamp, uniq, usageDataSchema } from "./data-loader-CKAeM9ir.js";
+import { description, log, logger, name, version } from "./logger-DxuNm8GV.js";
+import { detectMismatches, printMismatchReport } from "./debug-DMwiBRRn.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-pA-Z7D2o.js";
 import { readFile } from "node:fs/promises";
 import process$1 from "node:process";
 import { createServer } from "node:http";
@@ -1273,6 +1273,7 @@ const sharedArgs = {
 	},
 	locale: {
 		type: "string",
+		short: "l",
 		description: "Locale for date/time formatting (e.g., en-US, ja-JP, de-DE)",
 		default: "en-CA"
 	}
@@ -2949,7 +2950,7 @@ function stringWidth(string, options = {}) {
 	return width;
 }
 var import_cli_table3 = __toESM(require_cli_table3(), 1);
-var import_picocolors$7 = __toESM(require_picocolors(), 1);
+var import_picocolors$8 = __toESM(require_picocolors(), 1);
 /**
 * Responsive table class that adapts column widths based on terminal size
 * Automatically adjusts formatting and layout for different screen sizes
@@ -3185,7 +3186,7 @@ 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$7.default.gray(formatNumber(breakdown.inputTokens)), import_picocolors$7.default.gray(formatNumber(breakdown.outputTokens)), import_picocolors$7.default.gray(formatNumber(breakdown.cacheCreationTokens)), import_picocolors$7.default.gray(formatNumber(breakdown.cacheReadTokens)), import_picocolors$7.default.gray(formatNumber(totalTokens)), import_picocolors$7.default.gray(formatCurrency(breakdown.cost)));
+		row.push(import_picocolors$8.default.gray(formatNumber(breakdown.inputTokens)), import_picocolors$8.default.gray(formatNumber(breakdown.outputTokens)), import_picocolors$8.default.gray(formatNumber(breakdown.cacheCreationTokens)), import_picocolors$8.default.gray(formatNumber(breakdown.cacheReadTokens)), import_picocolors$8.default.gray(formatNumber(totalTokens)), import_picocolors$8.default.gray(formatCurrency(breakdown.cost)));
 		for (let i = 0; i < trailingColumns; i++) row.push("");
 		table.push(row);
 	}
@@ -3699,16 +3700,16 @@ const RESTORE_CURSOR = "\x1B8";
 function drawEmoji(emoji) {
 	return `${SAVE_CURSOR}${emoji}${RESTORE_CURSOR}${cursorForward(stringWidth(emoji))}`;
 }
-var import_picocolors$6 = __toESM(require_picocolors(), 1);
+var import_picocolors$7 = __toESM(require_picocolors(), 1);
 /**
 * Get rate indicator (HIGH/MODERATE/NORMAL) based on burn rate
 */
 function getRateIndicator(burnRate) {
 	if (burnRate == null) return "";
 	switch (true) {
-		case burnRate.tokensPerMinuteForIndicator > BURN_RATE_THRESHOLDS.HIGH: return import_picocolors$6.default.red(`${drawEmoji("⚡")} HIGH`);
-		case burnRate.tokensPerMinuteForIndicator > BURN_RATE_THRESHOLDS.MODERATE: return import_picocolors$6.default.yellow(`${drawEmoji("⚡")} MODERATE`);
-		default: return import_picocolors$6.default.green(`${drawEmoji("✓")} NORMAL`);
+		case burnRate.tokensPerMinuteForIndicator > BURN_RATE_THRESHOLDS.HIGH: return import_picocolors$7.default.red(`${drawEmoji("⚡")} HIGH`);
+		case burnRate.tokensPerMinuteForIndicator > BURN_RATE_THRESHOLDS.MODERATE: return import_picocolors$7.default.yellow(`${drawEmoji("⚡")} MODERATE`);
+		default: return import_picocolors$7.default.green(`${drawEmoji("✓")} NORMAL`);
 	}
 }
 /**
@@ -3725,7 +3726,7 @@ async function renderWaitingState(terminal, config, signal) {
 	terminal.startBuffering();
 	terminal.write(cursorTo(0, 0));
 	terminal.write(eraseDown);
-	terminal.write(import_picocolors$6.default.yellow("No active session block found. Waiting...\n"));
+	terminal.write(import_picocolors$7.default.yellow("No active session block found. Waiting...\n"));
 	terminal.write(cursorHide);
 	terminal.flush();
 	await delayWithAbort(config.refreshInterval, signal);
@@ -3783,8 +3784,8 @@ function renderLiveDisplay(terminal, block, config) {
 	const barWidth = boxWidth - labelWidth - maxRightTextWidth - spacing - boxPadding;
 	const sessionProgressBar = createProgressBar(elapsed, sessionDuration, barWidth, {
 		showPercentage: false,
-		fillChar: import_picocolors$6.default.cyan("█"),
-		emptyChar: import_picocolors$6.default.gray("░"),
+		fillChar: import_picocolors$7.default.cyan("█"),
+		emptyChar: import_picocolors$7.default.gray("░"),
 		leftBracket: "[",
 		rightBracket: "]"
 	});
@@ -3804,17 +3805,17 @@ function renderLiveDisplay(terminal, block, config) {
 	const detailsSpacing = 2;
 	const detailsAvailableWidth = boxWidth - 3 - detailsIndent;
 	terminal.write(`${marginStr}┌${"─".repeat(boxWidth - 2)}┐\n`);
-	terminal.write(`${marginStr}│${import_picocolors$6.default.bold(centerText("CLAUDE CODE - LIVE TOKEN USAGE MONITOR", boxWidth - 2))}│\n`);
+	terminal.write(`${marginStr}│${import_picocolors$7.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 = `${drawEmoji("⏱️")}${import_picocolors$6.default.bold(" SESSION")}`;
+	const sessionLabel = `${drawEmoji("⏱️")}${import_picocolors$7.default.bold(" SESSION")}`;
 	const sessionLabelWidth = stringWidth(sessionLabel);
 	const sessionBarStr = `${sessionLabel}${"".padEnd(Math.max(0, labelWidth - sessionLabelWidth))} ${sessionProgressBar} ${sessionRightText}`;
 	const sessionBarPadded = sessionBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(sessionBarStr)));
 	terminal.write(`${marginStr}│ ${sessionBarPadded}│\n`);
-	const sessionCol1 = `${import_picocolors$6.default.gray("Started:")} ${startTime}`;
-	const sessionCol2 = `${import_picocolors$6.default.gray("Elapsed:")} ${prettyMilliseconds(elapsed * 60 * 1e3, { compact: true })}`;
-	const sessionCol3 = `${import_picocolors$6.default.gray("Remaining:")} ${prettyMilliseconds(remaining * 60 * 1e3, { compact: true })} (${endTime})`;
+	const sessionCol1 = `${import_picocolors$7.default.gray("Started:")} ${startTime}`;
+	const sessionCol2 = `${import_picocolors$7.default.gray("Elapsed:")} ${prettyMilliseconds(elapsed * 60 * 1e3, { compact: true })}`;
+	const sessionCol3 = `${import_picocolors$7.default.gray("Remaining:")} ${prettyMilliseconds(remaining * 60 * 1e3, { compact: true })} (${endTime})`;
 	let sessionDetails = `${" ".repeat(detailsIndent)}${sessionCol1}${" ".repeat(detailsSpacing)}${sessionCol2}${" ".repeat(detailsSpacing)}${sessionCol3}`;
 	const sessionDetailsWidth = stringWidth(sessionCol1) + stringWidth(sessionCol2) + stringWidth(sessionCol3) + detailsSpacing * 2;
 	if (sessionDetailsWidth > detailsAvailableWidth) sessionDetails = `${" ".repeat(detailsIndent)}${sessionCol1}${" ".repeat(detailsSpacing)}${sessionCol3}`;
@@ -3826,7 +3827,7 @@ function renderLiveDisplay(terminal, block, config) {
 			minute: "2-digit",
 			hour12: true
 		}) ?? null;
-		const usageLimitResetTime = resetTime !== null ? import_picocolors$6.default.red(`${drawEmoji("❌")} USAGE LIMIT. RESET AT ${resetTime}`) : "";
+		const usageLimitResetTime = resetTime !== null ? import_picocolors$7.default.red(`${drawEmoji("❌")} USAGE LIMIT. RESET AT ${resetTime}`) : "";
 		usageLimitResetTimePadded = resetTime !== null ? usageLimitResetTime + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageLimitResetTime))) : null;
 	}
 	terminal.write(`${marginStr}│ ${sessionDetailsPadded}│\n`);
@@ -3834,31 +3835,31 @@ function renderLiveDisplay(terminal, block, config) {
 	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
 	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
 	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
-	let barColor = import_picocolors$6.default.green;
-	if (tokenPercent > 100) barColor = import_picocolors$6.default.red;
-	else if (tokenPercent > 80) barColor = import_picocolors$6.default.yellow;
+	let barColor = import_picocolors$7.default.green;
+	if (tokenPercent > 100) barColor = import_picocolors$7.default.red;
+	else if (tokenPercent > 80) barColor = import_picocolors$7.default.yellow;
 	const usageBar = config.tokenLimit != null && config.tokenLimit > 0 ? createProgressBar(totalTokens, config.tokenLimit, barWidth, {
 		showPercentage: false,
 		fillChar: barColor("█"),
-		emptyChar: import_picocolors$6.default.gray("░"),
+		emptyChar: import_picocolors$7.default.gray("░"),
 		leftBracket: "[",
 		rightBracket: "]"
-	}) : `[${import_picocolors$6.default.green("█".repeat(Math.floor(barWidth * .1)))}${import_picocolors$6.default.gray("░".repeat(barWidth - Math.floor(barWidth * .1)))}]`;
+	}) : `[${import_picocolors$7.default.green("█".repeat(Math.floor(barWidth * .1)))}${import_picocolors$7.default.gray("░".repeat(barWidth - Math.floor(barWidth * .1)))}]`;
 	const burnRate = calculateBurnRate(block);
 	const rateIndicator = getRateIndicator(burnRate);
 	const buildRateDisplay = (useShort) => {
-		if (burnRate == null) return `${import_picocolors$6.default.bold("Burn Rate:")} N/A`;
+		if (burnRate == null) return `${import_picocolors$7.default.bold("Burn Rate:")} N/A`;
 		const rateValue = Math.round(burnRate.tokensPerMinute);
 		const formattedRate = useShort ? formatTokensShort(rateValue) : formatNumber(rateValue);
-		return `${import_picocolors$6.default.bold("Burn Rate:")} ${formattedRate} token/min ${rateIndicator}`;
+		return `${import_picocolors$7.default.bold("Burn Rate:")} ${formattedRate} token/min ${rateIndicator}`;
 	};
-	const usageLabel = `${drawEmoji("🔥")}${import_picocolors$6.default.bold(" USAGE")}`;
+	const usageLabel = `${drawEmoji("🔥")}${import_picocolors$7.default.bold(" USAGE")}`;
 	const usageLabelWidth = stringWidth(usageLabel);
 	const usageBarStr = `${usageLabel}${"".padEnd(Math.max(0, labelWidth - usageLabelWidth))} ${usageBar} ${usageRightText}`;
 	let rateDisplay = buildRateDisplay(false);
-	let usageCol1 = `${import_picocolors$6.default.gray("Tokens:")} ${formatTokenDisplay(totalTokens, false)} (${rateDisplay})`;
-	let usageCol2 = config.tokenLimit != null && config.tokenLimit > 0 ? `${import_picocolors$6.default.gray("Limit:")} ${formatTokenDisplay(config.tokenLimit, false)} tokens` : "";
-	const usageCol3 = `${import_picocolors$6.default.gray("Cost:")} ${formatCurrency(block.costUSD)}`;
+	let usageCol1 = `${import_picocolors$7.default.gray("Tokens:")} ${formatTokenDisplay(totalTokens, false)} (${rateDisplay})`;
+	let usageCol2 = config.tokenLimit != null && config.tokenLimit > 0 ? `${import_picocolors$7.default.gray("Limit:")} ${formatTokenDisplay(config.tokenLimit, false)} tokens` : "";
+	const usageCol3 = `${import_picocolors$7.default.gray("Cost:")} ${formatCurrency(block.costUSD)}`;
 	let totalWidth = stringWidth(usageCol1);
 	if (usageCol2.length > 0) totalWidth += detailsSpacing + stringWidth(usageCol2);
 	totalWidth += detailsSpacing + stringWidth(usageCol3);
@@ -3866,8 +3867,8 @@ function renderLiveDisplay(terminal, block, config) {
 	if (totalWidth > detailsAvailableWidth) {
 		useTwoLineLayout = true;
 		rateDisplay = buildRateDisplay(true);
-		usageCol1 = `${import_picocolors$6.default.gray("Tokens:")} ${formatTokenDisplay(totalTokens, true)} (${rateDisplay})`;
-		if (usageCol2.length > 0) usageCol2 = `${import_picocolors$6.default.gray("Limit:")} ${formatTokenDisplay(config.tokenLimit, true)} tokens`;
+		usageCol1 = `${import_picocolors$7.default.gray("Tokens:")} ${formatTokenDisplay(totalTokens, true)} (${rateDisplay})`;
+		if (usageCol2.length > 0) usageCol2 = `${import_picocolors$7.default.gray("Limit:")} ${formatTokenDisplay(config.tokenLimit, true)} tokens`;
 	}
 	const usageBarPadded = usageBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageBarStr)));
 	terminal.write(`${marginStr}│ ${usageBarPadded}│\n`);
@@ -3891,30 +3892,30 @@ function renderLiveDisplay(terminal, block, config) {
 	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
 	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
 	if (projection != null) {
-		let projBarColor = import_picocolors$6.default.green;
-		if (projectedPercent > 100) projBarColor = import_picocolors$6.default.red;
-		else if (projectedPercent > 80) projBarColor = import_picocolors$6.default.yellow;
+		let projBarColor = import_picocolors$7.default.green;
+		if (projectedPercent > 100) projBarColor = import_picocolors$7.default.red;
+		else if (projectedPercent > 80) projBarColor = import_picocolors$7.default.yellow;
 		const projectionBar = config.tokenLimit != null && config.tokenLimit > 0 ? createProgressBar(projection.totalTokens, config.tokenLimit, barWidth, {
 			showPercentage: false,
 			fillChar: projBarColor("█"),
-			emptyChar: import_picocolors$6.default.gray("░"),
+			emptyChar: import_picocolors$7.default.gray("░"),
 			leftBracket: "[",
 			rightBracket: "]"
-		}) : `[${import_picocolors$6.default.green("█".repeat(Math.floor(barWidth * .15)))}${import_picocolors$6.default.gray("░".repeat(barWidth - Math.floor(barWidth * .15)))}]`;
-		const limitStatus = config.tokenLimit != null && config.tokenLimit > 0 ? projectedPercent > 100 ? import_picocolors$6.default.red(`${drawEmoji("❌")} WILL EXCEED LIMIT`) : projectedPercent > 80 ? import_picocolors$6.default.yellow(`${drawEmoji("⚠️")} APPROACHING LIMIT`) : import_picocolors$6.default.green(`${drawEmoji("✓")} WITHIN LIMIT`) : import_picocolors$6.default.green(`${drawEmoji("✓")} ON TRACK`);
-		const projLabel = `${drawEmoji("📈")}${import_picocolors$6.default.bold(" PROJECTION")}`;
+		}) : `[${import_picocolors$7.default.green("█".repeat(Math.floor(barWidth * .15)))}${import_picocolors$7.default.gray("░".repeat(barWidth - Math.floor(barWidth * .15)))}]`;
+		const limitStatus = config.tokenLimit != null && config.tokenLimit > 0 ? projectedPercent > 100 ? import_picocolors$7.default.red(`${drawEmoji("❌")} WILL EXCEED LIMIT`) : projectedPercent > 80 ? import_picocolors$7.default.yellow(`${drawEmoji("⚠️")} APPROACHING LIMIT`) : import_picocolors$7.default.green(`${drawEmoji("✓")} WITHIN LIMIT`) : import_picocolors$7.default.green(`${drawEmoji("✓")} ON TRACK`);
+		const projLabel = `${drawEmoji("📈")}${import_picocolors$7.default.bold(" PROJECTION")}`;
 		const projLabelWidth = stringWidth(projLabel);
 		const projBarStr = `${projLabel}${"".padEnd(Math.max(0, labelWidth - projLabelWidth))} ${projectionBar} ${projectionRightText}`;
 		const projBarPadded = projBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projBarStr)));
 		terminal.write(`${marginStr}│ ${projBarPadded}│\n`);
-		const projCol1 = `${import_picocolors$6.default.gray("Status:")} ${limitStatus}`;
-		let projCol2 = `${import_picocolors$6.default.gray("Tokens:")} ${formatTokenDisplay(projection.totalTokens, false)}`;
-		const projCol3 = `${import_picocolors$6.default.gray("Cost:")} ${formatCurrency(projection.totalCost)}`;
+		const projCol1 = `${import_picocolors$7.default.gray("Status:")} ${limitStatus}`;
+		let projCol2 = `${import_picocolors$7.default.gray("Tokens:")} ${formatTokenDisplay(projection.totalTokens, false)}`;
+		const projCol3 = `${import_picocolors$7.default.gray("Cost:")} ${formatCurrency(projection.totalCost)}`;
 		const projTotalWidth = stringWidth(projCol1) + stringWidth(projCol2) + stringWidth(projCol3) + detailsSpacing * 2;
 		let projUseTwoLineLayout = false;
 		if (projTotalWidth > detailsAvailableWidth) {
 			projUseTwoLineLayout = true;
-			projCol2 = `${import_picocolors$6.default.gray("Tokens:")} ${formatTokenDisplay(projection.totalTokens, true)}`;
+			projCol2 = `${import_picocolors$7.default.gray("Tokens:")} ${formatTokenDisplay(projection.totalTokens, true)}`;
 		}
 		if (projUseTwoLineLayout) {
 			const projDetailsLine1 = `${" ".repeat(detailsIndent)}${projCol1}`;
@@ -3938,7 +3939,7 @@ function renderLiveDisplay(terminal, block, config) {
 	}
 	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
 	const refreshText = `${drawEmoji("↻")} Refreshing every ${config.refreshInterval / 1e3}s  •  Press Ctrl+C to stop`;
-	terminal.write(`${marginStr}│${import_picocolors$6.default.gray(centerText(refreshText, boxWidth - 2))}│\n`);
+	terminal.write(`${marginStr}│${import_picocolors$7.default.gray(centerText(refreshText, boxWidth - 2))}│\n`);
 	terminal.write(`${marginStr}└${"─".repeat(boxWidth - 2)}┘\n`);
 }
 /**
@@ -3946,22 +3947,22 @@ function renderLiveDisplay(terminal, block, config) {
 */
 function renderCompactLiveDisplay(terminal, block, config, totalTokens, elapsed, remaining) {
 	const width = terminal.width;
-	terminal.write(`${import_picocolors$6.default.bold(centerText("LIVE MONITOR", width))}\n`);
+	terminal.write(`${import_picocolors$7.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$6.default.red("OVER") : tokenPercent > 80 ? import_picocolors$6.default.yellow("WARN") : import_picocolors$6.default.green("OK");
+		const status = tokenPercent > 100 ? import_picocolors$7.default.red("OVER") : tokenPercent > 80 ? import_picocolors$7.default.yellow("WARN") : import_picocolors$7.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$6.default.gray(`Refresh: ${config.refreshInterval / 1e3}s | Ctrl+C: stop\n`));
+	terminal.write(import_picocolors$7.default.gray(`Refresh: ${config.refreshInterval / 1e3}s | Ctrl+C: stop\n`));
 }
-var import_picocolors$5 = __toESM(require_picocolors(), 1);
+var import_picocolors$6 = __toESM(require_picocolors(), 1);
 var import_usingCtx = __toESM(require_usingCtx(), 1);
 async function startLiveMonitoring(config) {
 	try {
@@ -4024,7 +4025,7 @@ async function startLiveMonitoring(config) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			terminal.startBuffering();
 			terminal.clearScreen();
-			terminal.write(import_picocolors$5.default.red(`Error: ${errorMessage}\n`));
+			terminal.write(import_picocolors$6.default.red(`Error: ${errorMessage}\n`));
 			terminal.flush();
 			logger.error(`Live monitoring error: ${errorMessage}`);
 			await delayWithAbort(config.refreshInterval, abortController.signal).catch(() => {});
@@ -4035,7 +4036,7 @@ async function startLiveMonitoring(config) {
 		_usingCtx.d();
 	}
 }
-var import_picocolors$4 = __toESM(require_picocolors(), 1);
+var import_picocolors$5 = __toESM(require_picocolors(), 1);
 /**
 * Formats the time display for a session block
 * @param block - Session block to format
@@ -4120,7 +4121,7 @@ const blocksCommand = define({
 		},
 		sessionLength: {
 			type: "number",
-			short: "l",
+			short: "n",
 			description: `Session block duration in hours (default: ${DEFAULT_SESSION_DURATION_HOURS})`,
 			default: DEFAULT_SESSION_DURATION_HOURS
 		},
@@ -4244,19 +4245,19 @@ const blocksCommand = define({
 			const now = new Date();
 			const elapsed = Math.round((now.getTime() - block.startTime.getTime()) / (1e3 * 60));
 			const remaining = Math.round((block.endTime.getTime() - now.getTime()) / (1e3 * 60));
-			log(`Block Started: ${import_picocolors$4.default.cyan(block.startTime.toLocaleString())} (${import_picocolors$4.default.yellow(`${Math.floor(elapsed / 60)}h ${elapsed % 60}m`)} ago)`);
-			log(`Time Remaining: ${import_picocolors$4.default.green(`${Math.floor(remaining / 60)}h ${remaining % 60}m`)}\n`);
-			log(import_picocolors$4.default.bold("Current Usage:"));
+			log(`Block Started: ${import_picocolors$5.default.cyan(block.startTime.toLocaleString())} (${import_picocolors$5.default.yellow(`${Math.floor(elapsed / 60)}h ${elapsed % 60}m`)} ago)`);
+			log(`Time Remaining: ${import_picocolors$5.default.green(`${Math.floor(remaining / 60)}h ${remaining % 60}m`)}\n`);
+			log(import_picocolors$5.default.bold("Current Usage:"));
 			log(`  Input Tokens:     ${formatNumber(block.tokenCounts.inputTokens)}`);
 			log(`  Output Tokens:    ${formatNumber(block.tokenCounts.outputTokens)}`);
 			log(`  Total Cost:       ${formatCurrency(block.costUSD)}\n`);
 			if (burnRate != null) {
-				log(import_picocolors$4.default.bold("Burn Rate:"));
+				log(import_picocolors$5.default.bold("Burn Rate:"));
 				log(`  Tokens/minute:    ${formatNumber(burnRate.tokensPerMinute)}`);
 				log(`  Cost/hour:        ${formatCurrency(burnRate.costPerHour)}\n`);
 			}
 			if (projection != null) {
-				log(import_picocolors$4.default.bold("Projected Usage (if current rate continues):"));
+				log(import_picocolors$5.default.bold("Projected Usage (if current rate continues):"));
 				log(`  Total Tokens:     ${formatNumber(projection.totalTokens)}`);
 				log(`  Total Cost:       ${formatCurrency(projection.totalCost)}\n`);
 				if (ctx.values.tokenLimit != null) {
@@ -4265,8 +4266,8 @@ const blocksCommand = define({
 						const currentTokens = getTotalTokens(block.tokenCounts);
 						const remainingTokens = Math.max(0, limit - currentTokens);
 						const percentUsed = projection.totalTokens / limit * 100;
-						const status = percentUsed > 100 ? import_picocolors$4.default.red("EXCEEDS LIMIT") : percentUsed > BLOCKS_WARNING_THRESHOLD * 100 ? import_picocolors$4.default.yellow("WARNING") : import_picocolors$4.default.green("OK");
-						log(import_picocolors$4.default.bold("Token Limit Status:"));
+						const status = percentUsed > 100 ? import_picocolors$5.default.red("EXCEEDS LIMIT") : percentUsed > BLOCKS_WARNING_THRESHOLD * 100 ? import_picocolors$5.default.yellow("WARNING") : import_picocolors$5.default.green("OK");
+						log(import_picocolors$5.default.bold("Token Limit Status:"));
 						log(`  Limit:            ${formatNumber(limit)} tokens`);
 						log(`  Current Usage:    ${formatNumber(currentTokens)} (${(currentTokens / limit * 100).toFixed(1)}%)`);
 						log(`  Remaining:        ${formatNumber(remainingTokens)} tokens`);
@@ -4304,17 +4305,17 @@ const blocksCommand = define({
 			const useCompactFormat = terminalWidth < BLOCKS_COMPACT_WIDTH_THRESHOLD;
 			for (const block of blocks) if (block.isGap ?? false) {
 				const gapRow = [
-					import_picocolors$4.default.gray(formatBlockTime(block, useCompactFormat, ctx.values.locale)),
-					import_picocolors$4.default.gray("(inactive)"),
-					import_picocolors$4.default.gray("-"),
-					import_picocolors$4.default.gray("-")
+					import_picocolors$5.default.gray(formatBlockTime(block, useCompactFormat, ctx.values.locale)),
+					import_picocolors$5.default.gray("(inactive)"),
+					import_picocolors$5.default.gray("-"),
+					import_picocolors$5.default.gray("-")
 				];
-				if (actualTokenLimit != null && actualTokenLimit > 0) gapRow.push(import_picocolors$4.default.gray("-"));
-				gapRow.push(import_picocolors$4.default.gray("-"));
+				if (actualTokenLimit != null && actualTokenLimit > 0) gapRow.push(import_picocolors$5.default.gray("-"));
+				gapRow.push(import_picocolors$5.default.gray("-"));
 				table.push(gapRow);
 			} else {
 				const totalTokens = getTotalTokens(block.tokenCounts);
-				const status = block.isActive ? import_picocolors$4.default.green("ACTIVE") : "";
+				const status = block.isActive ? import_picocolors$5.default.green("ACTIVE") : "";
 				const row = [
 					formatBlockTime(block, useCompactFormat, ctx.values.locale),
 					status,
@@ -4324,7 +4325,7 @@ const blocksCommand = define({
 				if (actualTokenLimit != null && actualTokenLimit > 0) {
 					const percentage = totalTokens / actualTokenLimit * 100;
 					const percentText = `${percentage.toFixed(1)}%`;
-					row.push(percentage > 100 ? import_picocolors$4.default.red(percentText) : percentText);
+					row.push(percentage > 100 ? import_picocolors$5.default.red(percentText) : percentText);
 				}
 				row.push(formatCurrency(block.costUSD));
 				table.push(row);
@@ -4332,15 +4333,15 @@ const blocksCommand = define({
 					if (actualTokenLimit != null && actualTokenLimit > 0) {
 						const currentTokens = getTotalTokens(block.tokenCounts);
 						const remainingTokens = Math.max(0, actualTokenLimit - currentTokens);
-						const remainingText = remainingTokens > 0 ? formatNumber(remainingTokens) : import_picocolors$4.default.red("0");
+						const remainingText = remainingTokens > 0 ? formatNumber(remainingTokens) : import_picocolors$5.default.red("0");
 						const remainingPercent = (actualTokenLimit - currentTokens) / actualTokenLimit * 100;
-						const remainingPercentText = remainingPercent > 0 ? `${remainingPercent.toFixed(1)}%` : import_picocolors$4.default.red("0.0%");
+						const remainingPercentText = remainingPercent > 0 ? `${remainingPercent.toFixed(1)}%` : import_picocolors$5.default.red("0.0%");
 						const remainingRow = [
 							{
-								content: import_picocolors$4.default.gray(`(assuming ${formatNumber(actualTokenLimit)} token limit)`),
+								content: import_picocolors$5.default.gray(`(assuming ${formatNumber(actualTokenLimit)} token limit)`),
 								hAlign: "right"
 							},
-							import_picocolors$4.default.blue("REMAINING"),
+							import_picocolors$5.default.blue("REMAINING"),
 							"",
 							remainingText,
 							remainingPercentText,
@@ -4351,13 +4352,13 @@ const blocksCommand = define({
 					const projection = projectBlockUsage(block);
 					if (projection != null) {
 						const projectedTokens = formatNumber(projection.totalTokens);
-						const projectedText = actualTokenLimit != null && actualTokenLimit > 0 && projection.totalTokens > actualTokenLimit ? import_picocolors$4.default.red(projectedTokens) : projectedTokens;
+						const projectedText = actualTokenLimit != null && actualTokenLimit > 0 && projection.totalTokens > actualTokenLimit ? import_picocolors$5.default.red(projectedTokens) : projectedTokens;
 						const projectedRow = [
 							{
-								content: import_picocolors$4.default.gray("(assuming current burn rate)"),
+								content: import_picocolors$5.default.gray("(assuming current burn rate)"),
 								hAlign: "right"
 							},
-							import_picocolors$4.default.yellow("PROJECTED"),
+							import_picocolors$5.default.yellow("PROJECTED"),
 							"",
 							projectedText
 						];
@@ -4512,7 +4513,7 @@ function formatProjectName(projectName) {
 	if (aliases.has(parsed)) return aliases.get(parsed);
 	return parsed;
 }
-var import_picocolors$3 = __toESM(require_picocolors(), 1);
+var import_picocolors$4 = __toESM(require_picocolors(), 1);
 const dailyCommand = define({
 	name: "daily",
 	description: "Show usage report grouped by date",
@@ -4630,7 +4631,7 @@ const dailyCommand = define({
 						""
 					]);
 					table.push([
-						import_picocolors$3.default.cyan(`Project: ${formatProjectName(projectName)}`),
+						import_picocolors$4.default.cyan(`Project: ${formatProjectName(projectName)}`),
 						"",
 						"",
 						"",
@@ -4678,14 +4679,14 @@ const dailyCommand = define({
 				""
 			]);
 			table.push([
-				import_picocolors$3.default.yellow("Total"),
+				import_picocolors$4.default.yellow("Total"),
 				"",
-				import_picocolors$3.default.yellow(formatNumber(totals.inputTokens)),
-				import_picocolors$3.default.yellow(formatNumber(totals.outputTokens)),
-				import_picocolors$3.default.yellow(formatNumber(totals.cacheCreationTokens)),
-				import_picocolors$3.default.yellow(formatNumber(totals.cacheReadTokens)),
-				import_picocolors$3.default.yellow(formatNumber(getTotalTokens(totals))),
-				import_picocolors$3.default.yellow(formatCurrency(totals.totalCost))
+				import_picocolors$4.default.yellow(formatNumber(totals.inputTokens)),
+				import_picocolors$4.default.yellow(formatNumber(totals.outputTokens)),
+				import_picocolors$4.default.yellow(formatNumber(totals.cacheCreationTokens)),
+				import_picocolors$4.default.yellow(formatNumber(totals.cacheReadTokens)),
+				import_picocolors$4.default.yellow(formatNumber(getTotalTokens(totals))),
+				import_picocolors$4.default.yellow(formatCurrency(totals.totalCost))
 			]);
 			log(table.toString());
 			if (table.isCompactMode()) {
@@ -5169,7 +5170,7 @@ const mcpCommand = define({
 		}
 	}
 });
-var import_picocolors$2 = __toESM(require_picocolors(), 1);
+var import_picocolors$3 = __toESM(require_picocolors(), 1);
 const monthlyCommand = define({
 	name: "monthly",
 	description: "Show usage report grouped by month",
@@ -5288,14 +5289,14 @@ const monthlyCommand = define({
 				""
 			]);
 			table.push([
-				import_picocolors$2.default.yellow("Total"),
+				import_picocolors$3.default.yellow("Total"),
 				"",
-				import_picocolors$2.default.yellow(formatNumber(totals.inputTokens)),
-				import_picocolors$2.default.yellow(formatNumber(totals.outputTokens)),
-				import_picocolors$2.default.yellow(formatNumber(totals.cacheCreationTokens)),
-				import_picocolors$2.default.yellow(formatNumber(totals.cacheReadTokens)),
-				import_picocolors$2.default.yellow(formatNumber(getTotalTokens(totals))),
-				import_picocolors$2.default.yellow(formatCurrency(totals.totalCost))
+				import_picocolors$3.default.yellow(formatNumber(totals.inputTokens)),
+				import_picocolors$3.default.yellow(formatNumber(totals.outputTokens)),
+				import_picocolors$3.default.yellow(formatNumber(totals.cacheCreationTokens)),
+				import_picocolors$3.default.yellow(formatNumber(totals.cacheReadTokens)),
+				import_picocolors$3.default.yellow(formatNumber(getTotalTokens(totals))),
+				import_picocolors$3.default.yellow(formatCurrency(totals.totalCost))
 			]);
 			log(table.toString());
 			if (table.isCompactMode()) {
@@ -5305,7 +5306,7 @@ const monthlyCommand = define({
 		}
 	}
 });
-var import_picocolors$1 = __toESM(require_picocolors(), 1);
+var import_picocolors$2 = __toESM(require_picocolors(), 1);
 const sessionCommand = define({
 	name: "session",
 	description: "Show usage report grouped by conversation session",
@@ -5423,14 +5424,14 @@ const sessionCommand = define({
 				""
 			]);
 			table.push([
-				import_picocolors$1.default.yellow("Total"),
+				import_picocolors$2.default.yellow("Total"),
 				"",
-				import_picocolors$1.default.yellow(formatNumber(totals.inputTokens)),
-				import_picocolors$1.default.yellow(formatNumber(totals.outputTokens)),
-				import_picocolors$1.default.yellow(formatNumber(totals.cacheCreationTokens)),
-				import_picocolors$1.default.yellow(formatNumber(totals.cacheReadTokens)),
-				import_picocolors$1.default.yellow(formatNumber(getTotalTokens(totals))),
-				import_picocolors$1.default.yellow(formatCurrency(totals.totalCost)),
+				import_picocolors$2.default.yellow(formatNumber(totals.inputTokens)),
+				import_picocolors$2.default.yellow(formatNumber(totals.outputTokens)),
+				import_picocolors$2.default.yellow(formatNumber(totals.cacheCreationTokens)),
+				import_picocolors$2.default.yellow(formatNumber(totals.cacheReadTokens)),
+				import_picocolors$2.default.yellow(formatNumber(getTotalTokens(totals))),
+				import_picocolors$2.default.yellow(formatCurrency(totals.totalCost)),
 				""
 			]);
 			log(table.toString());
@@ -5441,6 +5442,121 @@ const sessionCommand = define({
 		}
 	}
 });
+const { stdin: stdin$1 } = process;
+async function getStdin() {
+	let result = "";
+	if (stdin$1.isTTY) return result;
+	stdin$1.setEncoding("utf8");
+	for await (const chunk of stdin$1) result += chunk;
+	return result;
+}
+getStdin.buffer = async () => {
+	const result = [];
+	let length = 0;
+	if (stdin$1.isTTY) return Buffer.concat([]);
+	for await (const chunk of stdin$1) {
+		result.push(chunk);
+		length += chunk.length;
+	}
+	return Buffer.concat(result, length);
+};
+var import_picocolors$1 = __toESM(require_picocolors(), 1);
+/**
+/**
+* Formats the remaining time for display
+* @param remaining - Remaining minutes
+* @returns Formatted time string
+*/
+function formatRemainingTime(remaining) {
+	const remainingHours = Math.floor(remaining / 60);
+	const remainingMins = remaining % 60;
+	if (remainingHours > 0) return `${remainingHours}h ${remainingMins}m left`;
+	return `${remainingMins}m left`;
+}
+const statuslineCommand = define({
+	name: "statusline",
+	description: "Display compact status line for Claude Code hooks (Beta)",
+	args: {},
+	async run() {
+		logger.level = 0;
+		const stdin$2 = await getStdin();
+		if (stdin$2.length === 0) {
+			log("❌ No input provided");
+			process$1.exit(1);
+		}
+		const hookDataJson = JSON.parse(stdin$2.trim());
+		const hookDataParseResult = statuslineHookJsonSchema.safeParse(hookDataJson);
+		if (!hookDataParseResult.success) {
+			log("❌ Invalid input format:", hookDataParseResult.error.message);
+			process$1.exit(1);
+		}
+		const hookData = hookDataParseResult.data;
+		const claudePaths = getClaudePaths();
+		if (claudePaths.length === 0) {
+			log("❌ No Claude data directory found");
+			process$1.exit(1);
+		}
+		const sessionId = hookData.session_id;
+		let sessionCost = null;
+		try {
+			const sessionData = await loadSessionUsageById(sessionId, { mode: "auto" });
+			if (sessionData != null) sessionCost = sessionData.totalCost;
+		} catch (error) {
+			logger.error("Failed to load session data:", error);
+		}
+		const today = new Date();
+		const todayStr = today.toISOString().split("T")[0];
+		let todayCost = 0;
+		try {
+			const dailyData = await loadDailyUsageData({
+				since: todayStr,
+				until: todayStr,
+				mode: "auto"
+			});
+			if (dailyData.length > 0) {
+				const totals = calculateTotals(dailyData);
+				todayCost = totals.totalCost;
+			}
+		} catch (error) {
+			logger.error("Failed to load daily data:", error);
+		}
+		let blockInfo = "";
+		let burnRateInfo = "";
+		try {
+			const blocks = await loadSessionBlockData({ mode: "auto" });
+			if (blocks.length === 0) blockInfo = "No active block";
+			else {
+				const activeBlock = blocks.find((block) => {
+					if (!block.isActive) return false;
+					return true;
+				});
+				if (activeBlock != null) {
+					const now = new Date();
+					const remaining = Math.round((activeBlock.endTime.getTime() - now.getTime()) / (1e3 * 60));
+					const blockCost = activeBlock.costUSD;
+					blockInfo = `${formatCurrency(blockCost)} block (${formatRemainingTime(remaining)})`;
+					const burnRate = calculateBurnRate(activeBlock);
+					if (burnRate != null) {
+						const costPerHour = burnRate.costPerHour;
+						const costPerHourStr = `${formatCurrency(costPerHour)}/hr`;
+						let coloredBurnRate = costPerHourStr;
+						if (burnRate.tokensPerMinuteForIndicator < 2e3) coloredBurnRate = import_picocolors$1.default.green(costPerHourStr);
+						else if (burnRate.tokensPerMinuteForIndicator < 5e3) coloredBurnRate = import_picocolors$1.default.yellow(costPerHourStr);
+						else coloredBurnRate = import_picocolors$1.default.red(costPerHourStr);
+						burnRateInfo = ` | 🔥 ${coloredBurnRate}`;
+					}
+				} else blockInfo = "No active block";
+			}
+		} catch (error) {
+			logger.error("Failed to load block data:", error);
+			blockInfo = "No active block";
+		}
+		const modelName = hookData.model.display_name;
+		const sessionDisplay = sessionCost !== null ? formatCurrency(sessionCost) : "N/A";
+		const statusLine = `🤖 ${modelName} | 💰 ${sessionDisplay} session / ${formatCurrency(todayCost)} today / ${blockInfo}${burnRateInfo}`;
+		log(statusLine);
+	}
+});
 var import_picocolors = __toESM(require_picocolors(), 1);
 const weeklyCommand = define({
 	name: "weekly",
@@ -5598,6 +5714,7 @@ subCommands.set("weekly", weeklyCommand);
 subCommands.set("session", sessionCommand);
 subCommands.set("blocks", blocksCommand);
 subCommands.set("mcp", mcpCommand);
+subCommands.set("statusline", statuslineCommand);
 /**
 * Default command when no subcommand is specified (defaults to daily)
 */

package/dist/{logger-D8Vy4evt.js → logger-DxuNm8GV.js}

@@ -951,12 +951,16 @@ function _getDefaultLogLevel() {
 }
 const consola = createConsola();
 var name = "ccusage";
-var version = "15.7.1";
+var version = "15.9.0";
 var description = "Usage analysis tool for Claude Code";
 /**
 * Application logger instance with package name tag
 */
 const logger = consola.withTag(name);
+if (process$1.env.LOG_LEVEL != null) {
+	const level = Number.parseInt(process$1.env.LOG_LEVEL, 10);
+	if (!Number.isNaN(level)) logger.level = level;
+}
 /**
 * Direct console.log function for cases where logger formatting is not desired
 */

package/dist/logger.js

@@ -1,2 +1,2 @@
-import { log, logger } from "./logger-D8Vy4evt.js";
+import { log, logger } from "./logger-DxuNm8GV.js";
 export { log, logger };

package/dist/{mcp-DCAyJs6a.js → mcp-pA-Z7D2o.js}

@@ -1,9 +1,9 @@
-import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-DWqNGcYq.js";
+import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-S0o3dB03.js";
 import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
-import { ZodFirstPartyTypeKind, ZodOptional, ZodType, arrayType, booleanType, discriminatedUnionType, enumType, filterDateSchema, literalType, numberType, objectType, optionalType, recordType, stringType, unionType, unknownType } from "./_types-ed8-0BH6.js";
+import { ZodFirstPartyTypeKind, ZodOptional, ZodType, arrayType, booleanType, discriminatedUnionType, enumType, filterDateSchema, literalType, numberType, objectType, optionalType, recordType, stringType, unionType, unknownType } from "./_types-B-1t4mxD.js";
 import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
-import { getClaudePaths, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-CclfHqXI.js";
-import { name, version } from "./logger-D8Vy4evt.js";
+import { getClaudePaths, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-CKAeM9ir.js";
+import { name, version } from "./logger-DxuNm8GV.js";
 import process from "node:process";
 const LATEST_PROTOCOL_VERSION = "2025-06-18";
 const SUPPORTED_PROTOCOL_VERSIONS = [

package/dist/mcp.d.ts

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

package/dist/mcp.js

@@ -1,8 +1,8 @@
-import "./pricing-fetcher-DWqNGcYq.js";
+import "./pricing-fetcher-S0o3dB03.js";
 import "./_token-utils-WjkbrjKv.js";
-import "./_types-ed8-0BH6.js";
+import "./_types-B-1t4mxD.js";
 import "./calculate-cost-BDqO4yWA.js";
-import "./data-loader-CclfHqXI.js";
-import "./logger-D8Vy4evt.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-DCAyJs6a.js";
+import "./data-loader-CKAeM9ir.js";
+import "./logger-DxuNm8GV.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-pA-Z7D2o.js";
 export { createMcpHttpApp, createMcpServer, startMcpServerStdio };

package/dist/{pricing-fetcher-AYfCy7g-.d.ts → pricing-fetcher-C9P2YKDv.d.ts}

@@ -122,6 +122,9 @@ declare const modelPricingSchema: z.ZodObject<{
  * Type definition for model pricing information
  */
 type ModelPricing = z.infer<typeof modelPricingSchema>;
+/**
+ * Zod schema for Claude Code statusline hook JSON data
+ */
 //#endregion
 //#region src/pricing-fetcher.d.ts
 /**

package/dist/{pricing-fetcher-DWqNGcYq.js → pricing-fetcher-S0o3dB03.js}

@@ -1,5 +1,5 @@
-import { modelPricingSchema } from "./_types-ed8-0BH6.js";
-import { logger } from "./logger-D8Vy4evt.js";
+import { modelPricingSchema } from "./_types-B-1t4mxD.js";
+import { logger } from "./logger-DxuNm8GV.js";
 import { createRequire } from "node:module";
 import path from "node:path";
 import F, { homedir } from "node:os";
@@ -406,6 +406,18 @@ var PricingFetcher = class {
 					"cache_creation_input_token_cost": 1875e-8,
 					"cache_read_input_token_cost": 15e-7
 				},
+				"claude-opus-4-1": {
+					"input_cost_per_token": 15e-6,
+					"output_cost_per_token": 75e-6,
+					"cache_creation_input_token_cost": 1875e-8,
+					"cache_read_input_token_cost": 15e-7
+				},
+				"claude-opus-4-1-20250805": {
+					"input_cost_per_token": 15e-6,
+					"output_cost_per_token": 75e-6,
+					"cache_creation_input_token_cost": 1875e-8,
+					"cache_read_input_token_cost": 15e-7
+				},
 				"claude-sonnet-4-20250514": {
 					"input_cost_per_token": 3e-6,
 					"output_cost_per_token": 15e-6,

package/dist/pricing-fetcher.d.ts

@@ -1,2 +1,2 @@
-import { PricingFetcher$1 as PricingFetcher } from "./pricing-fetcher-AYfCy7g-.js";
+import { PricingFetcher$1 as PricingFetcher } from "./pricing-fetcher-C9P2YKDv.js";
 export { PricingFetcher };

package/dist/pricing-fetcher.js

@@ -1,4 +1,4 @@
-import { PricingFetcher } from "./pricing-fetcher-DWqNGcYq.js";
-import "./_types-ed8-0BH6.js";
-import "./logger-D8Vy4evt.js";
+import { PricingFetcher } from "./pricing-fetcher-S0o3dB03.js";
+import "./_types-B-1t4mxD.js";
+import "./logger-DxuNm8GV.js";
 export { PricingFetcher };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccusage",
-  "version": "15.7.1",
+  "version": "15.9.0",
   "description": "Usage analysis tool for Claude Code",
   "homepage": "https://github.com/ryoppippi/ccusage#readme",
   "bugs": {