ccusage 16.1.1 → 16.2.0

package/config-schema.json

@@ -721,6 +721,18 @@
 									"markdownDescription": "Controls the visualization of the burn rate status",
 									"default": "off"
 								},
+								"costSource": {
+									"type": "string",
+									"enum": [
+										"auto",
+										"ccusage",
+										"cc",
+										"both"
+									],
+									"description": "Session cost source: auto (prefer CC then ccusage), ccusage (always calculate), cc (always use Claude Code cost), both (show both costs)",
+									"markdownDescription": "Session cost source: auto (prefer CC then ccusage), ccusage (always calculate), cc (always use Claude Code cost), both (show both costs)",
+									"default": "auto"
+								},
 								"cache": {
 									"type": "boolean",
 									"description": "Enable cache for status line output (default: true)",
@@ -733,6 +745,18 @@
 									"markdownDescription": "Refresh interval in seconds for cache expiry (default: 1)",
 									"default": 1
 								},
+								"contextLowThreshold": {
+									"type": "string",
+									"description": "Context usage percentage below which status is shown in green (0-100)",
+									"markdownDescription": "Context usage percentage below which status is shown in green (0-100)",
+									"default": 50
+								},
+								"contextMediumThreshold": {
+									"type": "string",
+									"description": "Context usage percentage below which status is shown in yellow (0-100)",
+									"markdownDescription": "Context usage percentage below which status is shown in yellow (0-100)",
+									"default": 80
+								},
 								"debug": {
 									"type": "boolean",
 									"description": "Show pricing mismatch information for debugging",

package/dist/{_types-BbEk8t2a.js → _types-DIdtMJ6V.js}

@@ -3015,7 +3015,28 @@ var ZodFirstPartyTypeKind;
 (function(ZodFirstPartyTypeKind$1) {
 	ZodFirstPartyTypeKind$1["ZodString"] = "ZodString", ZodFirstPartyTypeKind$1["ZodNumber"] = "ZodNumber", ZodFirstPartyTypeKind$1["ZodNaN"] = "ZodNaN", ZodFirstPartyTypeKind$1["ZodBigInt"] = "ZodBigInt", ZodFirstPartyTypeKind$1["ZodBoolean"] = "ZodBoolean", ZodFirstPartyTypeKind$1["ZodDate"] = "ZodDate", ZodFirstPartyTypeKind$1["ZodSymbol"] = "ZodSymbol", ZodFirstPartyTypeKind$1["ZodUndefined"] = "ZodUndefined", ZodFirstPartyTypeKind$1["ZodNull"] = "ZodNull", ZodFirstPartyTypeKind$1["ZodAny"] = "ZodAny", ZodFirstPartyTypeKind$1["ZodUnknown"] = "ZodUnknown", ZodFirstPartyTypeKind$1["ZodNever"] = "ZodNever", ZodFirstPartyTypeKind$1["ZodVoid"] = "ZodVoid", ZodFirstPartyTypeKind$1["ZodArray"] = "ZodArray", ZodFirstPartyTypeKind$1["ZodObject"] = "ZodObject", ZodFirstPartyTypeKind$1["ZodUnion"] = "ZodUnion", ZodFirstPartyTypeKind$1["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion", ZodFirstPartyTypeKind$1["ZodIntersection"] = "ZodIntersection", ZodFirstPartyTypeKind$1["ZodTuple"] = "ZodTuple", ZodFirstPartyTypeKind$1["ZodRecord"] = "ZodRecord", ZodFirstPartyTypeKind$1["ZodMap"] = "ZodMap", ZodFirstPartyTypeKind$1["ZodSet"] = "ZodSet", ZodFirstPartyTypeKind$1["ZodFunction"] = "ZodFunction", ZodFirstPartyTypeKind$1["ZodLazy"] = "ZodLazy", ZodFirstPartyTypeKind$1["ZodLiteral"] = "ZodLiteral", ZodFirstPartyTypeKind$1["ZodEnum"] = "ZodEnum", ZodFirstPartyTypeKind$1["ZodEffects"] = "ZodEffects", ZodFirstPartyTypeKind$1["ZodNativeEnum"] = "ZodNativeEnum", ZodFirstPartyTypeKind$1["ZodOptional"] = "ZodOptional", ZodFirstPartyTypeKind$1["ZodNullable"] = "ZodNullable", ZodFirstPartyTypeKind$1["ZodDefault"] = "ZodDefault", ZodFirstPartyTypeKind$1["ZodCatch"] = "ZodCatch", ZodFirstPartyTypeKind$1["ZodPromise"] = "ZodPromise", ZodFirstPartyTypeKind$1["ZodBranded"] = "ZodBranded", ZodFirstPartyTypeKind$1["ZodPipeline"] = "ZodPipeline", ZodFirstPartyTypeKind$1["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-const stringType = ZodString.create, numberType = ZodNumber.create, nanType = ZodNaN.create, bigIntType = ZodBigInt.create, booleanType = ZodBoolean.create, dateType = ZodDate.create, symbolType = ZodSymbol.create, undefinedType = ZodUndefined.create, nullType = ZodNull.create, anyType = ZodAny.create, unknownType = ZodUnknown.create, neverType = ZodNever.create, voidType = ZodVoid.create, arrayType = ZodArray.create, objectType = ZodObject.create, strictObjectType = ZodObject.strictCreate, unionType = ZodUnion.create, discriminatedUnionType = ZodDiscriminatedUnion.create, intersectionType = ZodIntersection.create, tupleType = ZodTuple.create, recordType = ZodRecord.create, mapType = ZodMap.create, setType = ZodSet.create, functionType = ZodFunction.create, lazyType = ZodLazy.create, literalType = ZodLiteral.create, enumType = ZodEnum.create, nativeEnumType = ZodNativeEnum.create, promiseType = ZodPromise.create, effectsType = ZodEffects.create, optionalType = ZodOptional.create, nullableType = ZodNullable.create, preprocessType = ZodEffects.createWithPreprocess, pipelineType = ZodPipeline.create, modelNameSchema = stringType().min(1, "Model name cannot be empty").brand(), sessionIdSchema = stringType().min(1, "Session ID cannot be empty").brand(), requestIdSchema = stringType().min(1, "Request ID cannot be empty").brand(), messageIdSchema = stringType().min(1, "Message ID cannot be empty").brand(), isoTimestampSchema = stringType().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/, "Invalid ISO timestamp").brand(), dailyDateSchema = stringType().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").brand(), activityDateSchema = stringType().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").brand(), monthlyDateSchema = stringType().regex(/^\d{4}-\d{2}$/, "Date must be in YYYY-MM format").brand(), weeklyDateSchema = stringType().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").brand(), filterDateSchema = stringType().regex(/^\d{8}$/, "Date must be in YYYYMMDD format").brand(), projectPathSchema = stringType().min(1, "Project path cannot be empty").brand(), versionSchema = stringType().regex(/^\d+\.\d+\.\d+/, "Invalid version format").brand(), createSessionId = (value) => sessionIdSchema.parse(value), createDailyDate = (value) => dailyDateSchema.parse(value), createMonthlyDate = (value) => monthlyDateSchema.parse(value), createWeeklyDate = (value) => weeklyDateSchema.parse(value), createProjectPath = (value) => projectPathSchema.parse(value);
+const stringType = ZodString.create, numberType = ZodNumber.create, nanType = ZodNaN.create, bigIntType = ZodBigInt.create, booleanType = ZodBoolean.create, dateType = ZodDate.create, symbolType = ZodSymbol.create, undefinedType = ZodUndefined.create, nullType = ZodNull.create, anyType = ZodAny.create, unknownType = ZodUnknown.create, neverType = ZodNever.create, voidType = ZodVoid.create, arrayType = ZodArray.create, objectType = ZodObject.create, strictObjectType = ZodObject.strictCreate, unionType = ZodUnion.create, discriminatedUnionType = ZodDiscriminatedUnion.create, intersectionType = ZodIntersection.create, tupleType = ZodTuple.create, recordType = ZodRecord.create, mapType = ZodMap.create, setType = ZodSet.create, functionType = ZodFunction.create, lazyType = ZodLazy.create, literalType = ZodLiteral.create, enumType = ZodEnum.create, nativeEnumType = ZodNativeEnum.create, promiseType = ZodPromise.create, effectsType = ZodEffects.create, optionalType = ZodOptional.create, nullableType = ZodNullable.create, preprocessType = ZodEffects.createWithPreprocess, pipelineType = ZodPipeline.create, coerce = {
+	string: ((arg) => ZodString.create({
+		...arg,
+		coerce: true
+	})),
+	number: ((arg) => ZodNumber.create({
+		...arg,
+		coerce: true
+	})),
+	boolean: ((arg) => ZodBoolean.create({
+		...arg,
+		coerce: true
+	})),
+	bigint: ((arg) => ZodBigInt.create({
+		...arg,
+		coerce: true
+	})),
+	date: ((arg) => ZodDate.create({
+		...arg,
+		coerce: true
+	}))
+}, modelNameSchema = stringType().min(1, "Model name cannot be empty").brand(), sessionIdSchema = stringType().min(1, "Session ID cannot be empty").brand(), requestIdSchema = stringType().min(1, "Request ID cannot be empty").brand(), messageIdSchema = stringType().min(1, "Message ID cannot be empty").brand(), isoTimestampSchema = stringType().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/, "Invalid ISO timestamp").brand(), dailyDateSchema = stringType().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").brand(), activityDateSchema = stringType().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").brand(), monthlyDateSchema = stringType().regex(/^\d{4}-\d{2}$/, "Date must be in YYYY-MM format").brand(), weeklyDateSchema = stringType().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").brand(), filterDateSchema = stringType().regex(/^\d{8}$/, "Date must be in YYYYMMDD format").brand(), projectPathSchema = stringType().min(1, "Project path cannot be empty").brand(), versionSchema = stringType().regex(/^\d+\.\d+\.\d+/, "Invalid version format").brand(), createSessionId = (value) => sessionIdSchema.parse(value), createDailyDate = (value) => dailyDateSchema.parse(value), createMonthlyDate = (value) => monthlyDateSchema.parse(value), createWeeklyDate = (value) => weeklyDateSchema.parse(value), createProjectPath = (value) => projectPathSchema.parse(value);
 function createBucket(value) {
 	return weeklyDateSchema.safeParse(value).success ? createWeeklyDate(value) : createMonthlyDate(value);
 }
@@ -3043,6 +3064,13 @@ const CostModes = [
 		current_dir: stringType(),
 		project_dir: stringType()
 	}),
-	version: stringType().optional()
+	version: stringType().optional(),
+	cost: objectType({
+		total_cost_usd: numberType(),
+		total_duration_ms: numberType().optional(),
+		total_api_duration_ms: numberType().optional(),
+		total_lines_added: numberType().optional(),
+		total_lines_removed: numberType().optional()
+	}).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 };
+export { CostModes, SortOrders, ZodFirstPartyTypeKind, ZodOptional, ZodType, activityDateSchema, arrayType, booleanType, coerce, 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-BgDfBZ05.js";
-import { DailyUsage, MonthlyUsage, SessionUsage, WeeklyUsage } from "./data-loader--Ga8BPdt.js";
+import { DailyUsage, MonthlyUsage, SessionUsage, WeeklyUsage } from "./data-loader-DewcQaMm.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-BbEk8t2a.js";
+import "./_types-DIdtMJ6V.js";
 import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
 export { calculateTotals, createTotalsObject, getTotalTokens };

package/dist/{data-loader-BR0q3F1S.js → data-loader-C7KK9Yu0.js}

@@ -1,7 +1,7 @@
-import { CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, CONTEXT_LOW_THRESHOLD_ENV, CONTEXT_MEDIUM_THRESHOLD_ENV, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_CONTEXT_USAGE_THRESHOLDS, DEFAULT_RECENT_DAYS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, isFailure, isPromise, isSuccess, require_usingCtx } from "./pricing-fetcher-_0Pbb-06.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, isSuccess, require_usingCtx } from "./pricing-fetcher-CoBMgxFA.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-BbEk8t2a.js";
-import { logger } from "./logger-4mOJMzU6.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-DIdtMJ6V.js";
+import { logger } from "./logger-DKCIi_ai.js";
 import a, { readFile } from "node:fs/promises";
 import path, { posix } from "node:path";
 import process$1 from "node:process";
@@ -2201,23 +2201,6 @@ function getClaudePaths() {
 - Or set ${CLAUDE_CONFIG_DIR_ENV} environment variable to valid directory path(s) containing a '${CLAUDE_PROJECTS_DIR_NAME}' subdirectory`.trim());
 	return paths;
 }
-function getContextUsageThresholds() {
-	const lowThresholdStr = process$1.env[CONTEXT_LOW_THRESHOLD_ENV], mediumThresholdStr = process$1.env[CONTEXT_MEDIUM_THRESHOLD_ENV];
-	let lowThreshold = DEFAULT_CONTEXT_USAGE_THRESHOLDS.LOW, mediumThreshold = DEFAULT_CONTEXT_USAGE_THRESHOLDS.MEDIUM;
-	if (lowThresholdStr != null) {
-		const parsed = Number.parseInt(lowThresholdStr, 10);
-		if (!Number.isNaN(parsed)) lowThreshold = Math.max(0, Math.min(100, parsed));
-	}
-	if (mediumThresholdStr != null) {
-		const parsed = Number.parseInt(mediumThresholdStr, 10);
-		if (!Number.isNaN(parsed)) mediumThreshold = Math.max(0, Math.min(100, parsed));
-	}
-	if (lowThreshold >= mediumThreshold) lowThreshold = DEFAULT_CONTEXT_USAGE_THRESHOLDS.LOW, mediumThreshold = DEFAULT_CONTEXT_USAGE_THRESHOLDS.MEDIUM;
-	return {
-		LOW: lowThreshold,
-		MEDIUM: mediumThreshold
-	};
-}
 function extractProjectFromPath(jsonlPath) {
 	const normalizedPath = jsonlPath.replace(/[/\\]/g, path.sep), segments = normalizedPath.split(path.sep), projectsIndex = segments.findIndex((segment) => segment === CLAUDE_PROJECTS_DIR_NAME);
 	if (projectsIndex === -1 || projectsIndex + 1 >= segments.length) return "unknown";
@@ -2761,4 +2744,4 @@ async function loadSessionBlockData(options) {
 		_usingCtx6.d();
 	}
 }
-export { DEFAULT_SESSION_DURATION_HOURS, bucketUsageSchema, calculateBurnRate, calculateContextTokens, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, filterRecentBlocks, formatDate, formatDateCompact, getClaudePaths, getContextUsageThresholds, getEarliestTimestamp, getUsageLimitResetTime, glob, globUsageFiles, identifySessionBlocks, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, toArray, transcriptMessageSchema, transcriptUsageSchema, uniq, unwrap, usageDataSchema, weeklyUsageSchema };
+export { DEFAULT_SESSION_DURATION_HOURS, bucketUsageSchema, calculateBurnRate, calculateContextTokens, 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, toArray, transcriptMessageSchema, transcriptUsageSchema, uniq, unwrap, usageDataSchema, weeklyUsageSchema };

package/dist/{data-loader--Ga8BPdt.d.ts → data-loader-DewcQaMm.d.ts}

@@ -66,16 +66,6 @@ type SessionBlock = {
  * @returns Array of valid Claude data directory paths
  */
 declare function getClaudePaths(): string[];
-/**
- * Get context usage percentage thresholds for color coding
- * Can be configured via environment variables or uses defaults
- * Validates and clamps values to 0-100 range and enforces LOW < MEDIUM ordering
- * @returns Context usage thresholds with LOW and MEDIUM percentages
- */
-declare function getContextUsageThresholds(): {
-  readonly LOW: number;
-  readonly MEDIUM: number;
-};
 /**
  * Extract project name from Claude JSONL file path
  * @param jsonlPath - Absolute path to JSONL file
@@ -806,4 +796,4 @@ declare function calculateContextTokens(transcriptPath: string, modelId?: string
  */
 declare function loadSessionBlockData(options?: LoadOptions): Promise<SessionBlock[]>;
 //#endregion
-export { BucketUsage, DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, WeeklyUsage, bucketUsageSchema, calculateContextTokens, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getContextUsageThresholds, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, transcriptMessageSchema, transcriptUsageSchema, usageDataSchema, weeklyUsageSchema };
+export { BucketUsage, DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, WeeklyUsage, bucketUsageSchema, calculateContextTokens, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, transcriptMessageSchema, transcriptUsageSchema, usageDataSchema, weeklyUsageSchema };

package/dist/data-loader.d.ts

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

package/dist/data-loader.js

@@ -1,6 +1,6 @@
-import "./pricing-fetcher-_0Pbb-06.js";
+import "./pricing-fetcher-CoBMgxFA.js";
 import "./_token-utils-WjkbrjKv.js";
-import "./_types-BbEk8t2a.js";
-import { bucketUsageSchema, calculateContextTokens, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getContextUsageThresholds, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, transcriptMessageSchema, transcriptUsageSchema, usageDataSchema, weeklyUsageSchema } from "./data-loader-BR0q3F1S.js";
-import "./logger-4mOJMzU6.js";
-export { bucketUsageSchema, calculateContextTokens, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getContextUsageThresholds, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, transcriptMessageSchema, transcriptUsageSchema, usageDataSchema, weeklyUsageSchema };
+import "./_types-DIdtMJ6V.js";
+import { bucketUsageSchema, calculateContextTokens, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, transcriptMessageSchema, transcriptUsageSchema, usageDataSchema, weeklyUsageSchema } from "./data-loader-C7KK9Yu0.js";
+import "./logger-DKCIi_ai.js";
+export { bucketUsageSchema, calculateContextTokens, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, transcriptMessageSchema, transcriptUsageSchema, usageDataSchema, weeklyUsageSchema };

package/dist/{debug-eBOoUv_j.js → debug-BOv8jTQu.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-_0Pbb-06.js";
-import { getClaudePaths, glob, unwrap, usageDataSchema } from "./data-loader-BR0q3F1S.js";
-import { logger } from "./logger-4mOJMzU6.js";
+import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-CoBMgxFA.js";
+import { getClaudePaths, glob, unwrap, usageDataSchema } from "./data-loader-C7KK9Yu0.js";
+import { logger } from "./logger-DKCIi_ai.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 var import_usingCtx = /* @__PURE__ */ __toESM(require_usingCtx(), 1);

package/dist/debug.js

@@ -1,7 +1,7 @@
-import "./pricing-fetcher-_0Pbb-06.js";
+import "./pricing-fetcher-CoBMgxFA.js";
 import "./_token-utils-WjkbrjKv.js";
-import "./_types-BbEk8t2a.js";
-import "./data-loader-BR0q3F1S.js";
-import "./logger-4mOJMzU6.js";
-import { detectMismatches, printMismatchReport } from "./debug-eBOoUv_j.js";
+import "./_types-DIdtMJ6V.js";
+import "./data-loader-C7KK9Yu0.js";
+import "./logger-DKCIi_ai.js";
+import { detectMismatches, printMismatchReport } from "./debug-BOv8jTQu.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, CONFIG_FILE_NAME, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PricingFetcher, WEEK_DAYS, __commonJSMin, __require, __toESM, inspect, inspectError, isFailure, isSuccess, map, pipe, require_usingCtx, succeed, try_ } from "./pricing-fetcher-_0Pbb-06.js";
+import { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, CONFIG_FILE_NAME, DEFAULT_CONTEXT_USAGE_THRESHOLDS, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PricingFetcher, WEEK_DAYS, __commonJSMin, __require, __toESM, andThen, fail, inspect, inspectError, isFailure, isSuccess, map, pipe, require_usingCtx, succeed, try_ } from "./pricing-fetcher-CoBMgxFA.js";
 import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
-import { CostModes, SortOrders, filterDateSchema, statuslineHookJsonSchema } from "./_types-BbEk8t2a.js";
+import { CostModes, SortOrders, coerce, filterDateSchema, statuslineHookJsonSchema } from "./_types-DIdtMJ6V.js";
 import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
-import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateContextTokens, calculateCostForEntry, createUniqueHash, filterRecentBlocks, formatDateCompact, getClaudePaths, getContextUsageThresholds, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, projectBlockUsage, sortFilesByTimestamp, toArray, uniq, unwrap, usageDataSchema } from "./data-loader-BR0q3F1S.js";
-import { description, log, logger, name, version } from "./logger-4mOJMzU6.js";
-import { detectMismatches, printMismatchReport } from "./debug-eBOoUv_j.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-BsLzYwL8.js";
+import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateContextTokens, calculateCostForEntry, createUniqueHash, filterRecentBlocks, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, projectBlockUsage, sortFilesByTimestamp, toArray, uniq, unwrap, usageDataSchema } from "./data-loader-C7KK9Yu0.js";
+import { description, log, logger, name, version } from "./logger-DKCIi_ai.js";
+import { detectMismatches, printMismatchReport } from "./debug-BOv8jTQu.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-DDHqWuGb.js";
 import a, { readFile, stat } from "node:fs/promises";
 import path, { join } from "node:path";
 import process$1 from "node:process";
@@ -817,7 +817,7 @@ var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		};
 	};
 	module.exports = createColors(), module.exports.createColors = createColors;
-})), import_picocolors$8 = /* @__PURE__ */ __toESM(require_picocolors(), 1), import_usingCtx$3 = /* @__PURE__ */ __toESM(require_usingCtx(), 1);
+})), import_picocolors$8 = /* @__PURE__ */ __toESM(require_picocolors(), 1), import_usingCtx$4 = /* @__PURE__ */ __toESM(require_usingCtx(), 1);
 function extractExplicitArgs(tokens) {
 	const explicit = {};
 	for (const token of tokens) if (typeof token === "object" && token !== null) {
@@ -2467,7 +2467,7 @@ function stringWidth(string, options = {}) {
 	}
 	return width;
 }
-var import_usingCtx$2 = /* @__PURE__ */ __toESM(require_usingCtx(), 1), ResponsiveTable = class {
+var import_usingCtx$3 = /* @__PURE__ */ __toESM(require_usingCtx(), 1), ResponsiveTable = class {
 	head;
 	rows = [];
 	colAligns;
@@ -2603,62 +2603,173 @@ async function getFileModifiedTime(filePath) {
 		catch: (error) => error
 	}), map((stats) => stats.mtime.getTime()), unwrap(0));
 }
-var LiveMonitor = class {
-	config;
-	fetcher = null;
-	lastFileTimestamps = /* @__PURE__ */ new Map();
-	processedHashes = /* @__PURE__ */ new Set();
-	allEntries = [];
-	constructor(config) {
-		if (this.config = config, config.mode !== "display") this.fetcher = new PricingFetcher();
-	}
-	[Symbol.dispose]() {
-		this.fetcher?.[Symbol.dispose]();
-	}
-	async getActiveBlock() {
-		const results = await globUsageFiles(this.config.claudePaths), allFiles = results.map((r) => r.file);
-		if (allFiles.length === 0) return null;
-		const filesToRead = [];
-		for (const file of allFiles) {
-			const timestamp$1 = await getEarliestTimestamp(file), lastTimestamp = this.lastFileTimestamps.get(file);
-			if (timestamp$1 != null && (lastTimestamp == null || timestamp$1.getTime() > lastTimestamp)) filesToRead.push(file), this.lastFileTimestamps.set(file, timestamp$1.getTime());
-		}
-		if (filesToRead.length > 0) {
-			const sortedFiles = await sortFilesByTimestamp(filesToRead);
-			for (const file of sortedFiles) {
-				const content = await readFile(file, "utf-8").catch(() => {
-					return "";
-				}), lines = content.trim().split("\n").filter((line) => line.length > 0);
-				for (const line of lines) try {
-					const parsed = JSON.parse(line), result = usageDataSchema.safeParse(parsed);
-					if (!result.success) continue;
-					const data = result.data, 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)), usageLimitResetTime = getUsageLimitResetTime(data);
-					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,
-						usageLimitResetTime: usageLimitResetTime ?? void 0
-					});
-				} catch {}
+var Node = class {
+	value;
+	next;
+	constructor(value$1) {
+		this.value = value$1;
+	}
+}, Queue = class {
+	#head;
+	#tail;
+	#size;
+	constructor() {
+		this.clear();
+	}
+	enqueue(value$1) {
+		const node = new Node(value$1);
+		if (this.#head) this.#tail.next = node, this.#tail = node;
+		else this.#head = node, this.#tail = node;
+		this.#size++;
+	}
+	dequeue() {
+		const current = this.#head;
+		if (current) return this.#head = this.#head.next, this.#size--, current.value;
+	}
+	peek() {
+		if (this.#head) return this.#head.value;
+	}
+	clear() {
+		this.#head = void 0, this.#tail = void 0, this.#size = 0;
+	}
+	get size() {
+		return this.#size;
+	}
+	*[Symbol.iterator]() {
+		let current = this.#head;
+		while (current) yield current.value, current = current.next;
+	}
+	*drain() {
+		while (this.#head) yield this.dequeue();
+	}
+};
+function pLimit(concurrency) {
+	validateConcurrency(concurrency);
+	const queue = new Queue();
+	let activeCount = 0;
+	const resumeNext = () => {
+		if (activeCount < concurrency && queue.size > 0) activeCount++, queue.dequeue()();
+	}, next = () => {
+		activeCount--, resumeNext();
+	}, run$1 = async (function_, resolve, arguments_) => {
+		const result = (async () => function_(...arguments_))();
+		resolve(result);
+		try {
+			await result;
+		} catch {}
+		next();
+	}, enqueue = (function_, resolve, arguments_) => {
+		if (new Promise((internalResolve) => {
+			queue.enqueue(internalResolve);
+		}).then(run$1.bind(void 0, function_, resolve, arguments_)), activeCount < concurrency) resumeNext();
+	}, generator = (function_, ...arguments_) => new Promise((resolve) => {
+		enqueue(function_, resolve, arguments_);
+	});
+	return Object.defineProperties(generator, {
+		activeCount: { get: () => activeCount },
+		pendingCount: { get: () => queue.size },
+		clearQueue: { value() {
+			queue.clear();
+		} },
+		concurrency: {
+			get: () => concurrency,
+			set(newConcurrency) {
+				validateConcurrency(newConcurrency), concurrency = newConcurrency, queueMicrotask(() => {
+					while (activeCount < concurrency && queue.size > 0) resumeNext();
+				});
 			}
+		},
+		map: { async value(array, function_) {
+			const promises = array.map((value$1, index) => this(function_, value$1, index));
+			return Promise.all(promises);
+		} }
+	}), generator;
+}
+function validateConcurrency(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+}
+var import_usingCtx$2 = /* @__PURE__ */ __toESM(require_usingCtx(), 1);
+const RETENTION_HOURS = 24, FILE_CONCURRENCY = 5;
+async function isRecentFile(filePath, cutoffTime) {
+	return pipe(try_({
+		try: stat(filePath),
+		catch: (error) => error
+	}), map((fileStats) => fileStats.mtime >= cutoffTime), unwrap(false));
+}
+function createLiveMonitorState(config) {
+	const fetcher = config.mode !== "display" ? new PricingFetcher() : null;
+	return {
+		fetcher,
+		lastFileTimestamps: /* @__PURE__ */ new Map(),
+		processedHashes: /* @__PURE__ */ new Set(),
+		allEntries: [],
+		[Symbol.dispose]() {
+			fetcher?.[Symbol.dispose]();
 		}
-		const blocks = identifySessionBlocks(this.allEntries, this.config.sessionDurationHours), sortedBlocks = this.config.order === "asc" ? blocks : blocks.reverse();
-		return sortedBlocks.find((block) => block.isActive) ?? null;
+	};
+}
+function clearLiveMonitorCache(state) {
+	state.lastFileTimestamps.clear(), state.processedHashes.clear(), state.allEntries = [];
+}
+function cleanupOldEntries(state, cutoffTime) {
+	const initialCount = state.allEntries.length;
+	if (state.allEntries = state.allEntries.filter((entry) => entry.timestamp >= cutoffTime), initialCount - state.allEntries.length > 100) state.processedHashes.clear();
+}
+async function processFileContent(state, config, content, cutoffTime) {
+	const lines = content.trim().split("\n").filter((line) => line.length > 0);
+	for (const line of lines) {
+		const dataResult = pipe(try_({
+			try: () => JSON.parse(line),
+			catch: (error) => error
+		})(), andThen((data$1) => {
+			const parseResult = usageDataSchema.safeParse(data$1);
+			return parseResult.success ? succeed(parseResult.data) : fail(parseResult.error);
+		}));
+		if (isFailure(dataResult)) continue;
+		const data = unwrap(dataResult), entryTime = new Date(data.timestamp);
+		if (entryTime < cutoffTime) continue;
+		const uniqueHash = createUniqueHash(data);
+		if (uniqueHash != null && state.processedHashes.has(uniqueHash)) continue;
+		if (uniqueHash != null) state.processedHashes.add(uniqueHash);
+		const costUSD = await (config.mode === "display" ? Promise.resolve(data.costUSD ?? 0) : calculateCostForEntry(data, config.mode, state.fetcher)), usageLimitResetTime = getUsageLimitResetTime(data);
+		state.allEntries.push({
+			timestamp: entryTime,
+			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,
+			usageLimitResetTime: usageLimitResetTime ?? void 0
+		});
 	}
-	clearCache() {
-		this.lastFileTimestamps.clear(), this.processedHashes.clear(), this.allEntries = [];
+}
+async function getActiveBlock(state, config) {
+	const cutoffTime = /* @__PURE__ */ new Date(Date.now() - RETENTION_HOURS * 60 * 60 * 1e3), results = await globUsageFiles(config.claudePaths), allFiles = results.map((r) => r.file);
+	if (allFiles.length === 0) return null;
+	const candidateFiles = [];
+	for (const file of allFiles) if (await isRecentFile(file, cutoffTime)) candidateFiles.push(file);
+	const filesToRead = [];
+	for (const file of candidateFiles) {
+		const timestamp$1 = await getEarliestTimestamp(file), lastTimestamp = state.lastFileTimestamps.get(file);
+		if (timestamp$1 != null && (lastTimestamp == null || timestamp$1.getTime() > lastTimestamp)) filesToRead.push(file), state.lastFileTimestamps.set(file, timestamp$1.getTime());
 	}
-};
+	if (cleanupOldEntries(state, cutoffTime), filesToRead.length > 0) {
+		const sortedFiles = await sortFilesByTimestamp(filesToRead), fileLimit = pLimit(FILE_CONCURRENCY), fileResults = await Promise.allSettled(sortedFiles.map(async (file) => fileLimit(async () => ({
+			file,
+			content: await readFile(file, "utf-8")
+		}))));
+		for (const result of fileResults) if (result.status === "fulfilled") {
+			const { content } = result.value;
+			await processFileContent(state, config, content, cutoffTime);
+		}
+	}
+	const blocks = identifySessionBlocks(state.allEntries, config.sessionDurationHours), sortedBlocks = config.order === "asc" ? blocks : blocks.reverse();
+	return sortedBlocks.find((block) => block.isActive) ?? null;
+}
 function delay(ms, options = {}) {
 	const { signal, persistent = true } = options;
 	return signal?.aborted ? Promise.reject(signal.reason) : new Promise((resolve, reject) => {
@@ -3044,16 +3155,16 @@ async function startLiveMonitoring(config) {
 		var _usingCtx = (0, import_usingCtx$1.default)();
 		const terminal = new TerminalManager(), abortController = new AbortController();
 		let lastRenderTime = 0;
-		const cleanup = () => {
-			if (abortController.abort(), terminal.cleanup(), terminal.clearScreen(), logger.info("Live monitoring stopped."), process$1.exitCode == null) process$1.exit(0);
-		};
-		process$1.on("SIGINT", cleanup), process$1.on("SIGTERM", cleanup), terminal.enterAlternateScreen(), terminal.enableSyncMode(), terminal.clearScreen(), terminal.hideCursor();
-		const monitor = _usingCtx.u(new LiveMonitor({
+		const monitorConfig = {
 			claudePaths: config.claudePaths,
 			sessionDurationHours: config.sessionDurationHours,
 			mode: config.mode,
 			order: config.order
-		})), monitoringResult = await try_({
+		}, monitorState = _usingCtx.u(createLiveMonitorState(monitorConfig)), cleanup = () => {
+			if (abortController.abort(), terminal.cleanup(), terminal.clearScreen(), logger.info("Live monitoring stopped."), process$1.exitCode == null) process$1.exit(0);
+		};
+		process$1.on("SIGINT", cleanup), process$1.on("SIGTERM", cleanup), terminal.enterAlternateScreen(), terminal.enableSyncMode(), terminal.clearScreen(), terminal.hideCursor();
+		const monitoringResult = await try_({
 			try: async () => {
 				while (!abortController.signal.aborted) {
 					const now = Date.now(), timeSinceLastRender = now - lastRenderTime;
@@ -3061,8 +3172,8 @@ async function startLiveMonitoring(config) {
 						await delayWithAbort(MIN_RENDER_INTERVAL_MS - timeSinceLastRender, abortController.signal);
 						continue;
 					}
-					const activeBlock = await monitor.getActiveBlock();
-					if (monitor.clearCache(), activeBlock == null) {
+					const activeBlock = await getActiveBlock(monitorState, monitorConfig);
+					if (clearLiveMonitorCache(monitorState), activeBlock == null) {
 						await renderWaitingState(terminal, config, abortController.signal);
 						continue;
 					}
@@ -5214,7 +5325,12 @@ const visualBurnRateChoices = [
 	"emoji",
 	"text",
 	"emoji-text"
-], statuslineCommand = define({
+], costSourceChoices = [
+	"auto",
+	"ccusage",
+	"cc",
+	"both"
+], contextThresholdSchema = coerce.number().int().min(0, "Context threshold must be at least 0").max(100, "Context threshold must be at most 100"), statuslineCommand = define({
 	name: "statusline",
 	description: "Display compact status line for Claude Code hooks with hybrid time+file caching (Beta)",
 	toKebab: true,
@@ -5232,6 +5348,14 @@ const visualBurnRateChoices = [
 			negatable: false,
 			toKebab: true
 		},
+		costSource: {
+			type: "enum",
+			choices: costSourceChoices,
+			description: "Session cost source: auto (prefer CC then ccusage), ccusage (always calculate), cc (always use Claude Code cost), both (show both costs)",
+			default: "auto",
+			negatable: false,
+			toKebab: true
+		},
 		cache: {
 			type: "boolean",
 			description: "Enable cache for status line output (default: true)",
@@ -5242,11 +5366,23 @@ const visualBurnRateChoices = [
 			description: `Refresh interval in seconds for cache expiry (default: ${DEFAULT_REFRESH_INTERVAL_SECONDS})`,
 			default: DEFAULT_REFRESH_INTERVAL_SECONDS
 		},
+		contextLowThreshold: {
+			type: "custom",
+			description: "Context usage percentage below which status is shown in green (0-100)",
+			parse: (value$1) => contextThresholdSchema.parse(value$1),
+			default: DEFAULT_CONTEXT_USAGE_THRESHOLDS.LOW
+		},
+		contextMediumThreshold: {
+			type: "custom",
+			description: "Context usage percentage below which status is shown in yellow (0-100)",
+			parse: (value$1) => contextThresholdSchema.parse(value$1),
+			default: DEFAULT_CONTEXT_USAGE_THRESHOLDS.MEDIUM
+		},
 		config: sharedArgs.config,
 		debug: sharedArgs.debug
 	},
 	async run(ctx) {
-		logger.level = 0;
+		if (logger.level = 0, ctx.values.contextLowThreshold >= ctx.values.contextMediumThreshold) throw new Error(`Context low threshold (${ctx.values.contextLowThreshold}) must be less than medium threshold (${ctx.values.contextMediumThreshold})`);
 		const config = loadConfig(ctx.values.config, ctx.values.debug), mergedOptions = mergeConfigWithArgs(ctx, config, ctx.values.debug), refreshInterval = mergedOptions.refreshInterval, stdin$2 = await getStdin();
 		if (stdin$2.length === 0) log("❌ No input provided"), process$1.exit(1);
 		const hookDataJson = JSON.parse(stdin$2.trim()), hookDataParseResult = statuslineHookJsonSchema.safeParse(hookDataJson);
@@ -5299,33 +5435,55 @@ const visualBurnRateChoices = [
 		}
 		const mainProcessingResult = pipe(await try_({
 			try: async () => {
-				const sessionCost = await pipe(try_({
-					try: loadSessionUsageById(sessionId, {
-						mode: "auto",
-						offline: mergedOptions.offline
-					}),
-					catch: (error) => error
-				}), map((sessionCost$1) => sessionCost$1?.totalCost), inspectError((error) => logger.error("Failed to load session data:", error)), unwrap(void 0)), today = /* @__PURE__ */ new Date(), todayStr = today.toISOString().split("T")[0]?.replace(/-/g, "") ?? "", todayCost = await pipe(try_({
-					try: loadDailyUsageData({
+				const { sessionCost, ccCost, ccusageCost } = await (async () => {
+					const costSource = ctx.values.costSource, getCcusageCost = async () => {
+						return pipe(try_({
+							try: async () => loadSessionUsageById(sessionId, {
+								mode: "auto",
+								offline: mergedOptions.offline
+							}),
+							catch: (error) => error
+						})(), map((sessionCost$1) => sessionCost$1?.totalCost), inspectError((error) => logger.error("Failed to load session data:", error)), unwrap(void 0));
+					};
+					if (costSource === "both") {
+						const ccCost$1 = hookData.cost?.total_cost_usd, ccusageCost$1 = await getCcusageCost();
+						return {
+							ccCost: ccCost$1,
+							ccusageCost: ccusageCost$1
+						};
+					}
+					if (costSource === "cc") return { sessionCost: hookData.cost?.total_cost_usd };
+					if (costSource === "ccusage") {
+						const cost = await getCcusageCost();
+						return { sessionCost: cost };
+					}
+					if (costSource === "auto") {
+						if (hookData.cost?.total_cost_usd != null) return { sessionCost: hookData.cost.total_cost_usd };
+						const cost = await getCcusageCost();
+						return { sessionCost: cost };
+					}
+					return {};
+				})(), today = /* @__PURE__ */ new Date(), todayStr = today.toISOString().split("T")[0]?.replace(/-/g, "") ?? "", todayCost = await pipe(try_({
+					try: async () => loadDailyUsageData({
 						since: todayStr,
 						until: todayStr,
 						mode: "auto",
 						offline: mergedOptions.offline
 					}),
 					catch: (error) => error
-				}), map((dailyData) => {
+				})(), map((dailyData) => {
 					if (dailyData.length > 0) {
 						const totals = calculateTotals(dailyData);
 						return totals.totalCost;
 					}
 					return 0;
 				}), inspectError((error) => logger.error("Failed to load daily data:", error)), unwrap(0)), { blockInfo, burnRateInfo } = await pipe(try_({
-					try: loadSessionBlockData({
+					try: async () => loadSessionBlockData({
 						mode: "auto",
 						offline: mergedOptions.offline
 					}),
 					catch: (error) => error
-				}), map((blocks) => {
+				})(), map((blocks) => {
 					if (blocks.length === 0) return {
 						blockInfo: "No active block",
 						burnRateInfo: ""
@@ -5371,11 +5529,17 @@ const visualBurnRateChoices = [
 				})), contextInfo = await pipe(try_({
 					try: calculateContextTokens(hookData.transcript_path, hookData.model.id, mergedOptions.offline),
 					catch: (error) => error
-				}), inspectError((error) => logger.debug(`Failed to calculate context tokens: ${error instanceof Error ? error.message : String(error)}`)), map((ctx$1) => {
-					if (ctx$1 == null) return void 0;
-					const thresholds = getContextUsageThresholds(), color = ctx$1.percentage < thresholds.LOW ? import_picocolors$1.default.green : ctx$1.percentage < thresholds.MEDIUM ? import_picocolors$1.default.yellow : import_picocolors$1.default.red, coloredPercentage = color(`${ctx$1.percentage}%`), tokenDisplay = ctx$1.inputTokens.toLocaleString();
+				}), inspectError((error) => logger.debug(`Failed to calculate context tokens: ${error instanceof Error ? error.message : String(error)}`)), map((contextResult) => {
+					if (contextResult == null) return void 0;
+					const color = contextResult.percentage < ctx.values.contextLowThreshold ? import_picocolors$1.default.green : contextResult.percentage < ctx.values.contextMediumThreshold ? import_picocolors$1.default.yellow : import_picocolors$1.default.red, coloredPercentage = color(`${contextResult.percentage}%`), tokenDisplay = contextResult.inputTokens.toLocaleString();
 					return `${tokenDisplay} (${coloredPercentage})`;
-				}), unwrap(void 0)), modelName = hookData.model.display_name, sessionDisplay = sessionCost != null ? formatCurrency(sessionCost) : "N/A", statusLine = `🤖 ${modelName} | 💰 ${sessionDisplay} session / ${formatCurrency(todayCost)} today / ${blockInfo}${burnRateInfo} | 🧠 ${contextInfo ?? "N/A"}`;
+				}), unwrap(void 0)), modelName = hookData.model.display_name, sessionDisplay = (() => {
+					if (ccCost != null || ccusageCost != null) {
+						const ccDisplay = ccCost != null ? formatCurrency(ccCost) : "N/A", ccusageDisplay = ccusageCost != null ? formatCurrency(ccusageCost) : "N/A";
+						return `(${ccDisplay} cc / ${ccusageDisplay} ccusage)`;
+					}
+					return sessionCost != null ? formatCurrency(sessionCost) : "N/A";
+				})(), statusLine = `🤖 ${modelName} | 💰 ${sessionDisplay} session / ${formatCurrency(todayCost)} today / ${blockInfo}${burnRateInfo} | 🧠 ${contextInfo ?? "N/A"}`;
 				return statusLine;
 			},
 			catch: (error) => error

package/dist/{logger-4mOJMzU6.js → logger-DKCIi_ai.js}

@@ -761,7 +761,7 @@ function _getDefaultLogLevel() {
 	return g ? LogLevels.debug : R ? LogLevels.warn : LogLevels.info;
 }
 const consola = createConsola$1();
-var name = "ccusage", version = "16.1.1", description = "Usage analysis tool for Claude Code";
+var name = "ccusage", version = "16.2.0", description = "Usage analysis tool for Claude Code";
 const logger = consola.withTag(name);
 if (process$1.env.LOG_LEVEL != null) {
 	const level = Number.parseInt(process$1.env.LOG_LEVEL, 10);

package/dist/logger.js

@@ -1,2 +1,2 @@
-import { log, logger } from "./logger-4mOJMzU6.js";
+import { log, logger } from "./logger-DKCIi_ai.js";
 export { log, logger };

package/dist/{mcp-BsLzYwL8.js → mcp-DDHqWuGb.js}

@@ -1,9 +1,9 @@
-import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-_0Pbb-06.js";
+import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-CoBMgxFA.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-BbEk8t2a.js";
+import { ZodFirstPartyTypeKind, ZodOptional, ZodType, arrayType, booleanType, discriminatedUnionType, enumType, filterDateSchema, literalType, numberType, objectType, optionalType, recordType, stringType, unionType, unknownType } from "./_types-DIdtMJ6V.js";
 import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
-import { getClaudePaths, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-BR0q3F1S.js";
-import { name, version } from "./logger-4mOJMzU6.js";
+import { getClaudePaths, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-C7KK9Yu0.js";
+import { name, version } from "./logger-DKCIi_ai.js";
 import process from "node:process";
 const LATEST_PROTOCOL_VERSION = "2025-06-18", SUPPORTED_PROTOCOL_VERSIONS = [
 	LATEST_PROTOCOL_VERSION,

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import "./pricing-fetcher-BgDfBZ05.js";
-import { LoadOptions } from "./data-loader--Ga8BPdt.js";
+import { LoadOptions } from "./data-loader-DewcQaMm.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-_0Pbb-06.js";
+import "./pricing-fetcher-CoBMgxFA.js";
 import "./_token-utils-WjkbrjKv.js";
-import "./_types-BbEk8t2a.js";
+import "./_types-DIdtMJ6V.js";
 import "./calculate-cost-BDqO4yWA.js";
-import "./data-loader-BR0q3F1S.js";
-import "./logger-4mOJMzU6.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-BsLzYwL8.js";
+import "./data-loader-C7KK9Yu0.js";
+import "./logger-DKCIi_ai.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-DDHqWuGb.js";
 export { createMcpHttpApp, createMcpServer, startMcpServerStdio };

package/dist/{pricing-fetcher-_0Pbb-06.js → pricing-fetcher-CoBMgxFA.js}

@@ -1,5 +1,5 @@
-import { modelPricingSchema } from "./_types-BbEk8t2a.js";
-import { logger } from "./logger-4mOJMzU6.js";
+import { modelPricingSchema } from "./_types-DIdtMJ6V.js";
+import { logger } from "./logger-DKCIi_ai.js";
 import { createRequire } from "node:module";
 import path from "node:path";
 import F, { homedir } from "node:os";
@@ -99,7 +99,7 @@ const LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/m
 }, DEFAULT_CONTEXT_USAGE_THRESHOLDS = {
 	LOW: 50,
 	MEDIUM: 80
-}, CONTEXT_LOW_THRESHOLD_ENV = "CCUSAGE_CONTEXT_LOW_THRESHOLD", CONTEXT_MEDIUM_THRESHOLD_ENV = "CCUSAGE_CONTEXT_MEDIUM_THRESHOLD", WEEK_DAYS = [
+}, WEEK_DAYS = [
 	"sunday",
 	"monday",
 	"tuesday",
@@ -292,9 +292,9 @@ var require_usingCtx = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					"output_cost_per_token": 15e-6,
 					"cache_creation_input_token_cost": 375e-8,
 					"cache_read_input_token_cost": 3e-7,
-					"max_tokens": 64e3,
-					"max_input_tokens": 2e5,
-					"max_output_tokens": 64e3
+					"max_tokens": 1e6,
+					"max_input_tokens": 1e6,
+					"max_output_tokens": 1e6
 				},
 				"claude-3-7-sonnet-latest": {
 					"input_cost_per_token": 3e-6,
@@ -399,4 +399,4 @@ var require_usingCtx = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		return cost;
 	}
 };
-export { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, CONFIG_FILE_NAME, CONTEXT_LOW_THRESHOLD_ENV, CONTEXT_MEDIUM_THRESHOLD_ENV, DEBUG_MATCH_THRESHOLD_PERCENT, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_CONTEXT_USAGE_THRESHOLDS, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, WEEK_DAYS, __commonJSMin, __require, __toESM, inspect, inspectError, isFailure, isPromise, isSuccess, map, pipe, require_usingCtx, succeed, try_ };
+export { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, CONFIG_FILE_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_CONTEXT_USAGE_THRESHOLDS, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, WEEK_DAYS, __commonJSMin, __require, __toESM, andThen, fail, inspect, inspectError, isFailure, isPromise, isSuccess, map, pipe, require_usingCtx, succeed, try_ };

package/dist/pricing-fetcher.js

@@ -1,4 +1,4 @@
-import { PricingFetcher } from "./pricing-fetcher-_0Pbb-06.js";
-import "./_types-BbEk8t2a.js";
-import "./logger-4mOJMzU6.js";
+import { PricingFetcher } from "./pricing-fetcher-CoBMgxFA.js";
+import "./_types-DIdtMJ6V.js";
+import "./logger-DKCIi_ai.js";
 export { PricingFetcher };

package/package.json

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