fengming 0.3.3 → 0.3.5

package/dist/session-cost-usage-Bs5yIOBH.js

@@ -0,0 +1,1600 @@
+import { c as normalizeOptionalString } from "./string-coerce-DKw2K5wM.js";
+import { a as asFiniteNumber } from "./number-coercion-D1aDmIZp.js";
+import { i as formatErrorMessage } from "./errors-5ePGD43N.js";
+import { t as createSubsystemLogger } from "./subsystem-46gngkCY.js";
+import { n as replaceFileAtomic } from "./replace-file-DmlX6XsI.js";
+import { t as runTasksWithConcurrency } from "./run-with-concurrency-5cC57eDC.js";
+import { C as parseUsageCountedSessionIdFromFileName, S as parseSessionArchiveTimestamp, b as isUsageCountedSessionTranscriptFileName, h as isSessionArchiveArtifactName, i as resolveSessionFilePath, l as resolveSessionTranscriptsDirForAgent, m as isPrimarySessionTranscriptFileName } from "./paths-C79m3Aob.js";
+import { n as stripInboundMetadata } from "./strip-inbound-meta-XdRMOffD.js";
+import { T as stripMessageIdHints, _ as countToolResults, v as extractToolCallNames, w as stripEnvelope } from "./session-utils.fs-D-Ly08WB.js";
+import { o as normalizeUsage } from "./usage-B1VvYcZy.js";
+import { a as resolveModelCostConfig, o as resolveModelCostConfigFingerprint, t as estimateUsageCost } from "./usage-format-DWO9ckX3.js";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+//#region src/infra/session-cost-usage.ts
+const emptyTotals = () => ({
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	totalCost: 0,
+	inputCost: 0,
+	outputCost: 0,
+	cacheReadCost: 0,
+	cacheWriteCost: 0,
+	missingCostEntries: 0
+});
+const USAGE_COST_CACHE_VERSION = 4;
+const USAGE_COST_CACHE_FILE = ".usage-cost-cache.json";
+const USAGE_COST_CACHE_LOCK_WRITE_GRACE_MS = 1e4;
+const USAGE_COST_TRANSCRIPT_STAT_CONCURRENCY = 32;
+const logger = createSubsystemLogger("usage-cost-cache");
+const usageCostRefreshes = /* @__PURE__ */ new Map();
+const cloneTotals = (totals) => ({
+	input: totals.input,
+	output: totals.output,
+	cacheRead: totals.cacheRead,
+	cacheWrite: totals.cacheWrite,
+	totalTokens: totals.totalTokens,
+	totalCost: totals.totalCost,
+	inputCost: totals.inputCost,
+	outputCost: totals.outputCost,
+	cacheReadCost: totals.cacheReadCost,
+	cacheWriteCost: totals.cacheWriteCost,
+	missingCostEntries: totals.missingCostEntries
+});
+const addTotals = (target, source) => {
+	target.input += source.input;
+	target.output += source.output;
+	target.cacheRead += source.cacheRead;
+	target.cacheWrite += source.cacheWrite;
+	target.totalTokens += source.totalTokens;
+	target.totalCost += source.totalCost;
+	target.inputCost += source.inputCost;
+	target.outputCost += source.outputCost;
+	target.cacheReadCost += source.cacheReadCost;
+	target.cacheWriteCost += source.cacheWriteCost;
+	target.missingCostEntries += source.missingCostEntries;
+};
+function resolveUsageCostPricingFingerprint(config) {
+	return resolveModelCostConfigFingerprint(config);
+}
+function resolveUsageCostCachePath(agentId) {
+	return path.join(resolveSessionTranscriptsDirForAgent(agentId), USAGE_COST_CACHE_FILE);
+}
+function resolveUsageCostCacheLockPath(cachePath) {
+	return `${cachePath}.lock`;
+}
+function parseUsageCostCacheLock(raw) {
+	const parsed = JSON.parse(raw);
+	if (!parsed || typeof parsed !== "object") return null;
+	const lock = parsed;
+	if (typeof lock.pid !== "number" || !Number.isInteger(lock.pid) || lock.pid <= 0 || typeof lock.startedAt !== "number" || !Number.isFinite(lock.startedAt) || lock.token !== void 0 && typeof lock.token !== "string") return null;
+	return {
+		pid: lock.pid,
+		startedAt: lock.startedAt,
+		token: lock.token
+	};
+}
+async function readUsageCostCacheLockState(lockPath) {
+	try {
+		const lock = parseUsageCostCacheLock(await fs.promises.readFile(lockPath, "utf-8"));
+		if (lock) return {
+			state: "valid",
+			lock
+		};
+	} catch (err) {
+		if (err.code === "ENOENT") return { state: "missing" };
+	}
+	const stats = await fs.promises.stat(lockPath).catch(() => null);
+	if (!stats) return { state: "missing" };
+	return {
+		state: "malformed",
+		mtimeMs: stats.mtimeMs
+	};
+}
+async function readUsageCostCacheLock(lockPath) {
+	const result = await readUsageCostCacheLockState(lockPath);
+	return result.state === "valid" ? result.lock : null;
+}
+function isMalformedUsageCostCacheLockRecent(mtimeMs) {
+	return Date.now() - mtimeMs < USAGE_COST_CACHE_LOCK_WRITE_GRACE_MS;
+}
+async function writeUsageCostCacheLockAtomically(lockPath, lock) {
+	const tempPath = `${lockPath}.${process.pid}.${process.hrtime.bigint()}.tmp`;
+	await fs.promises.writeFile(tempPath, `${JSON.stringify(lock)}\n`, { flag: "wx" });
+	try {
+		await fs.promises.link(tempPath, lockPath);
+	} finally {
+		await fs.promises.rm(tempPath, { force: true }).catch(() => void 0);
+	}
+}
+function isProcessRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err.code === "EPERM";
+	}
+}
+async function isUsageCostCacheRefreshRunning(cachePath) {
+	const lockPath = resolveUsageCostCacheLockPath(cachePath);
+	const result = await readUsageCostCacheLockState(lockPath);
+	if (result.state === "missing") return false;
+	if (result.state === "malformed") {
+		if (isMalformedUsageCostCacheLockRecent(result.mtimeMs)) return true;
+		await fs.promises.rm(lockPath, { force: true }).catch(() => void 0);
+		return false;
+	}
+	const lock = result.lock;
+	if (isProcessRunning(lock.pid)) return true;
+	await fs.promises.rm(lockPath, { force: true }).catch(() => void 0);
+	return false;
+}
+async function acquireUsageCostCacheRefreshLock(cachePath) {
+	const lockPath = resolveUsageCostCacheLockPath(cachePath);
+	await fs.promises.mkdir(path.dirname(lockPath), { recursive: true });
+	const lock = {
+		pid: process.pid,
+		startedAt: Date.now(),
+		token: `${process.pid}:${Date.now()}:${process.hrtime.bigint()}`
+	};
+	try {
+		await writeUsageCostCacheLockAtomically(lockPath, lock);
+		return {
+			acquired: true,
+			release: async () => {
+				const current = await readUsageCostCacheLock(lockPath);
+				if (current?.pid === lock.pid && current.startedAt === lock.startedAt && current.token === lock.token) await fs.promises.rm(lockPath, { force: true }).catch(() => void 0);
+			}
+		};
+	} catch (err) {
+		if (err.code !== "EEXIST") throw err;
+		if (await isUsageCostCacheRefreshRunning(cachePath)) return {
+			acquired: false,
+			release: async () => void 0
+		};
+		await fs.promises.rm(lockPath, { force: true }).catch(() => void 0);
+		return acquireUsageCostCacheRefreshLock(cachePath);
+	}
+}
+function normalizeUsageCostCache(raw) {
+	if (!raw || typeof raw !== "object") return {
+		version: USAGE_COST_CACHE_VERSION,
+		updatedAt: 0,
+		files: {}
+	};
+	const record = raw;
+	if (record.version !== USAGE_COST_CACHE_VERSION || !record.files || typeof record.files !== "object") return {
+		version: USAGE_COST_CACHE_VERSION,
+		updatedAt: 0,
+		files: {}
+	};
+	return {
+		version: USAGE_COST_CACHE_VERSION,
+		updatedAt: asFiniteNumber(record.updatedAt) ?? 0,
+		files: record.files
+	};
+}
+async function readUsageCostCache(cachePath) {
+	try {
+		const raw = await fs.promises.readFile(cachePath, "utf-8");
+		return normalizeUsageCostCache(JSON.parse(raw));
+	} catch {
+		return {
+			version: USAGE_COST_CACHE_VERSION,
+			updatedAt: 0,
+			files: {}
+		};
+	}
+}
+async function writeUsageCostCache(cachePath, cache) {
+	await replaceFileAtomic({
+		filePath: cachePath,
+		content: `${JSON.stringify(cache)}\n`,
+		tempPrefix: ".usage-cost-cache"
+	});
+}
+async function listUsageCountedTranscriptFileStats(agentId, params) {
+	const sessionsDir = params?.sessionsDir ?? resolveSessionTranscriptsDirForAgent(agentId);
+	const { results } = await runTasksWithConcurrency({
+		tasks: (await fs.promises.readdir(sessionsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile() && isUsageCountedSessionTranscriptFileName(entry.name)).map((entry) => async () => {
+			const filePath = path.join(sessionsDir, entry.name);
+			const stats = await fs.promises.stat(filePath).catch(() => null);
+			if (!stats) return;
+			if (params?.minMtimeMs !== void 0 && stats.mtimeMs < params.minMtimeMs) return;
+			return {
+				filePath,
+				size: stats.size,
+				mtimeMs: stats.mtimeMs
+			};
+		}),
+		limit: USAGE_COST_TRANSCRIPT_STAT_CONCURRENCY
+	});
+	return results.filter((file) => Boolean(file));
+}
+async function listUsageCountedTranscriptFiles(agentId, params) {
+	return await listUsageCountedTranscriptFileStats(agentId, params);
+}
+function isUsageCostCacheEntryFresh(params) {
+	return Boolean(params.entry && params.entry.size === params.file.size && params.entry.mtimeMs === params.file.mtimeMs && params.entry.pricingFingerprint === params.pricingFingerprint && (!params.requireSessionSummary || params.entry.sessionSummary));
+}
+function canUseUsageCostCacheEntryForPartial(params) {
+	return Boolean(params.entry && params.entry.size <= params.file.size && params.entry.mtimeMs <= params.file.mtimeMs && params.entry.pricingFingerprint === params.pricingFingerprint);
+}
+function getUsageCostStaleFiles(params) {
+	const sessionSummaryFiles = params.sessionSummaryFiles ?? /* @__PURE__ */ new Set();
+	return params.files.filter((file) => !isUsageCostCacheEntryFresh({
+		entry: params.cache.files[file.filePath],
+		file,
+		pricingFingerprint: params.pricingFingerprint,
+		requireSessionSummary: sessionSummaryFiles.has(file.filePath)
+	}));
+}
+function countUsableUsageCostCacheFiles(params) {
+	const filesByPath = new Map(params.files.map((file) => [file.filePath, file]));
+	let cachedFiles = 0;
+	for (const [filePath, entry] of Object.entries(params.cache.files)) {
+		const file = filesByPath.get(filePath);
+		if (file && canUseUsageCostCacheEntryForPartial({
+			entry,
+			file,
+			pricingFingerprint: params.pricingFingerprint
+		})) cachedFiles += 1;
+	}
+	return cachedFiles;
+}
+function buildCostUsageSummaryFromCache(params) {
+	const dailyMap = /* @__PURE__ */ new Map();
+	const totals = emptyTotals();
+	const filesByPath = new Map(params.files.map((file) => [file.filePath, file]));
+	const staleFiles = getUsageCostStaleFiles({
+		cache: params.cache,
+		files: params.files,
+		pricingFingerprint: params.pricingFingerprint
+	});
+	const cachedFiles = countUsableUsageCostCacheFiles({
+		cache: params.cache,
+		files: params.files,
+		pricingFingerprint: params.pricingFingerprint
+	});
+	for (const [filePath, entry] of Object.entries(params.cache.files)) {
+		const file = filesByPath.get(filePath);
+		if (!file || !canUseUsageCostCacheEntryForPartial({
+			entry,
+			file,
+			pricingFingerprint: params.pricingFingerprint
+		})) continue;
+		for (const usageEntry of entry.usageEntries) {
+			if (usageEntry.timestamp < params.startMs || usageEntry.timestamp > params.endMs) continue;
+			const date = formatDayKey(new Date(usageEntry.timestamp));
+			const bucket = dailyMap.get(date) ?? emptyTotals();
+			addTotals(bucket, usageEntry);
+			dailyMap.set(date, bucket);
+			addTotals(totals, usageEntry);
+		}
+	}
+	const daily = Array.from(dailyMap.entries()).map(([date, bucket]) => Object.assign({ date }, bucket)).toSorted((a, b) => a.date.localeCompare(b.date));
+	const days = Math.ceil((params.endMs - params.startMs) / (1440 * 60 * 1e3)) + 1;
+	const status = params.refreshing ? "refreshing" : staleFiles.length > 0 ? cachedFiles > 0 ? "partial" : "stale" : "fresh";
+	return {
+		updatedAt: Date.now(),
+		days,
+		daily,
+		totals,
+		cacheStatus: {
+			status,
+			cachedFiles,
+			pendingFiles: staleFiles.length,
+			staleFiles: staleFiles.length,
+			refreshedAt: params.cache.updatedAt || void 0
+		}
+	};
+}
+function isSessionSummaryContainedInRange(summary, startMs, endMs) {
+	return (summary.firstActivity === void 0 || summary.firstActivity >= startMs) && (summary.lastActivity === void 0 || summary.lastActivity <= endMs);
+}
+function buildSessionCostSummaryFromCacheEntry(params) {
+	if (!params.entry.transcriptEntries) return null;
+	const totals = emptyTotals();
+	const activityDatesSet = /* @__PURE__ */ new Set();
+	const dailyMap = /* @__PURE__ */ new Map();
+	const dailyMessageMap = /* @__PURE__ */ new Map();
+	const utcQuarterHourMessageMap = /* @__PURE__ */ new Map();
+	const utcQuarterHourTokenMap = /* @__PURE__ */ new Map();
+	const dailyLatencyMap = /* @__PURE__ */ new Map();
+	const dailyModelUsageMap = /* @__PURE__ */ new Map();
+	const messageCounts = {
+		total: 0,
+		user: 0,
+		assistant: 0,
+		toolCalls: 0,
+		toolResults: 0,
+		errors: 0
+	};
+	const toolUsageMap = /* @__PURE__ */ new Map();
+	const modelUsageMap = /* @__PURE__ */ new Map();
+	const errorStopReasons = new Set([
+		"error",
+		"aborted",
+		"timeout"
+	]);
+	const latencyValues = [];
+	let firstActivity;
+	let lastActivity;
+	let lastUserTimestamp;
+	const maxLatencyMs = 720 * 60 * 1e3;
+	for (const entry of params.entry.transcriptEntries) {
+		const ts = entry.timestamp;
+		if (ts !== void 0 && ts < params.startMs) continue;
+		if (ts !== void 0 && ts > params.endMs) continue;
+		if (ts !== void 0) {
+			firstActivity = firstActivity === void 0 ? ts : Math.min(firstActivity, ts);
+			lastActivity = lastActivity === void 0 ? ts : Math.max(lastActivity, ts);
+		}
+		if (entry.role === "user") {
+			messageCounts.user += 1;
+			messageCounts.total += 1;
+			if (ts !== void 0) lastUserTimestamp = ts;
+		}
+		if (entry.role === "assistant") {
+			messageCounts.assistant += 1;
+			messageCounts.total += 1;
+			if (ts !== void 0) {
+				const latencyMs = entry.durationMs ?? (lastUserTimestamp !== void 0 ? Math.max(0, ts - lastUserTimestamp) : void 0);
+				if (latencyMs !== void 0 && Number.isFinite(latencyMs) && latencyMs <= maxLatencyMs) {
+					latencyValues.push(latencyMs);
+					const dayKey = formatDayKey(new Date(ts));
+					const dailyLatencies = dailyLatencyMap.get(dayKey) ?? [];
+					dailyLatencies.push(latencyMs);
+					dailyLatencyMap.set(dayKey, dailyLatencies);
+				}
+			}
+		}
+		if (entry.toolNames.length > 0) {
+			messageCounts.toolCalls += entry.toolNames.length;
+			for (const name of entry.toolNames) toolUsageMap.set(name, (toolUsageMap.get(name) ?? 0) + 1);
+		}
+		if (entry.toolResultCounts.total > 0) {
+			messageCounts.toolResults += entry.toolResultCounts.total;
+			messageCounts.errors += entry.toolResultCounts.errors;
+		}
+		if (entry.stopReason && errorStopReasons.has(entry.stopReason)) messageCounts.errors += 1;
+		if (ts !== void 0) {
+			const date = new Date(ts);
+			const dayKey = formatDayKey(date);
+			activityDatesSet.add(dayKey);
+			const daily = dailyMessageMap.get(dayKey) ?? {
+				date: dayKey,
+				total: 0,
+				user: 0,
+				assistant: 0,
+				toolCalls: 0,
+				toolResults: 0,
+				errors: 0
+			};
+			daily.total += entry.role === "user" || entry.role === "assistant" ? 1 : 0;
+			if (entry.role === "user") daily.user += 1;
+			else if (entry.role === "assistant") daily.assistant += 1;
+			daily.toolCalls += entry.toolNames.length;
+			daily.toolResults += entry.toolResultCounts.total;
+			daily.errors += entry.toolResultCounts.errors;
+			if (entry.stopReason && errorStopReasons.has(entry.stopReason)) daily.errors += 1;
+			dailyMessageMap.set(dayKey, daily);
+			const quarterBucket = getUtcQuarterHourBucketKey(date);
+			const utcQuarterHour = utcQuarterHourMessageMap.get(quarterBucket.key) ?? {
+				date: quarterBucket.date,
+				quarterIndex: quarterBucket.quarterIndex,
+				total: 0,
+				user: 0,
+				assistant: 0,
+				toolCalls: 0,
+				toolResults: 0,
+				errors: 0
+			};
+			utcQuarterHour.total += entry.role === "user" || entry.role === "assistant" ? 1 : 0;
+			if (entry.role === "user") utcQuarterHour.user += 1;
+			else if (entry.role === "assistant") utcQuarterHour.assistant += 1;
+			utcQuarterHour.toolCalls += entry.toolNames.length;
+			utcQuarterHour.toolResults += entry.toolResultCounts.total;
+			utcQuarterHour.errors += entry.toolResultCounts.errors;
+			if (entry.stopReason && errorStopReasons.has(entry.stopReason)) utcQuarterHour.errors += 1;
+			utcQuarterHourMessageMap.set(quarterBucket.key, utcQuarterHour);
+		}
+		const usageTotals = entry.usageTotals;
+		if (!usageTotals) continue;
+		addTotals(totals, usageTotals);
+		if (ts !== void 0) {
+			const date = new Date(ts);
+			const dayKey = formatDayKey(date);
+			const componentTokens = usageTotals.input + usageTotals.output + usageTotals.cacheRead + usageTotals.cacheWrite;
+			const existingDaily = dailyMap.get(dayKey) ?? {
+				tokens: 0,
+				cost: 0
+			};
+			existingDaily.tokens += componentTokens;
+			existingDaily.cost += usageTotals.totalCost;
+			dailyMap.set(dayKey, existingDaily);
+			const quarterBucket = getUtcQuarterHourBucketKey(date);
+			const utcQuarterHourToken = utcQuarterHourTokenMap.get(quarterBucket.key) ?? {
+				date: quarterBucket.date,
+				quarterIndex: quarterBucket.quarterIndex,
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				totalCost: 0
+			};
+			utcQuarterHourToken.input += usageTotals.input;
+			utcQuarterHourToken.output += usageTotals.output;
+			utcQuarterHourToken.cacheRead += usageTotals.cacheRead;
+			utcQuarterHourToken.cacheWrite += usageTotals.cacheWrite;
+			utcQuarterHourToken.totalTokens += usageTotals.totalTokens;
+			utcQuarterHourToken.totalCost += usageTotals.totalCost;
+			utcQuarterHourTokenMap.set(quarterBucket.key, utcQuarterHourToken);
+			if (entry.provider || entry.model) {
+				const dailyModelKey = `${dayKey}::${entry.provider ?? "unknown"}::${entry.model ?? "unknown"}`;
+				const dailyModel = dailyModelUsageMap.get(dailyModelKey) ?? {
+					date: dayKey,
+					provider: entry.provider,
+					model: entry.model,
+					tokens: 0,
+					cost: 0,
+					count: 0
+				};
+				dailyModel.tokens += componentTokens;
+				dailyModel.cost += usageTotals.totalCost;
+				dailyModel.count += 1;
+				dailyModelUsageMap.set(dailyModelKey, dailyModel);
+			}
+		}
+		if (entry.provider || entry.model) {
+			const modelKey = `${entry.provider ?? "unknown"}::${entry.model ?? "unknown"}`;
+			const modelUsage = modelUsageMap.get(modelKey) ?? {
+				provider: entry.provider,
+				model: entry.model,
+				count: 0,
+				totals: emptyTotals()
+			};
+			modelUsage.count += 1;
+			addTotals(modelUsage.totals, usageTotals);
+			modelUsageMap.set(modelKey, modelUsage);
+		}
+	}
+	const dailyBreakdown = Array.from(dailyMap.entries()).map(([date, data]) => ({
+		date,
+		tokens: data.tokens,
+		cost: data.cost
+	})).toSorted((a, b) => a.date.localeCompare(b.date));
+	const dailyMessageCounts = Array.from(dailyMessageMap.values()).toSorted((a, b) => a.date.localeCompare(b.date));
+	const utcQuarterHourMessageCounts = Array.from(utcQuarterHourMessageMap.values()).toSorted((a, b) => a.date.localeCompare(b.date) || a.quarterIndex - b.quarterIndex);
+	const utcQuarterHourTokenUsage = Array.from(utcQuarterHourTokenMap.values()).toSorted((a, b) => a.date.localeCompare(b.date) || a.quarterIndex - b.quarterIndex);
+	const dailyLatency = Array.from(dailyLatencyMap.entries()).map(([date, values]) => {
+		const stats = computeLatencyStats(values);
+		if (!stats) return null;
+		return Object.assign({ date }, stats);
+	}).filter((entry) => Boolean(entry)).toSorted((a, b) => a.date.localeCompare(b.date));
+	const dailyModelUsage = Array.from(dailyModelUsageMap.values()).toSorted((a, b) => a.date.localeCompare(b.date) || b.cost - a.cost);
+	const toolUsage = toolUsageMap.size ? {
+		totalCalls: Array.from(toolUsageMap.values()).reduce((sum, count) => sum + count, 0),
+		uniqueTools: toolUsageMap.size,
+		tools: Array.from(toolUsageMap.entries()).map(([name, count]) => ({
+			name,
+			count
+		})).toSorted((a, b) => b.count - a.count)
+	} : void 0;
+	const modelUsage = Array.from(modelUsageMap.values()).toSorted((a, b) => {
+		const costDiff = (b.totals?.totalCost ?? 0) - (a.totals?.totalCost ?? 0);
+		if (costDiff !== 0) return costDiff;
+		return (b.totals?.totalTokens ?? 0) - (a.totals?.totalTokens ?? 0);
+	});
+	return {
+		sessionId: params.sessionId,
+		sessionFile: params.sessionFile,
+		firstActivity,
+		lastActivity,
+		durationMs: firstActivity !== void 0 && lastActivity !== void 0 ? Math.max(0, lastActivity - firstActivity) : void 0,
+		activityDates: Array.from(activityDatesSet).toSorted(),
+		dailyBreakdown,
+		dailyMessageCounts,
+		utcQuarterHourMessageCounts: utcQuarterHourMessageCounts.length ? utcQuarterHourMessageCounts : void 0,
+		utcQuarterHourTokenUsage: utcQuarterHourTokenUsage.length ? utcQuarterHourTokenUsage : void 0,
+		dailyLatency: dailyLatency.length ? dailyLatency : void 0,
+		dailyModelUsage: dailyModelUsage.length ? dailyModelUsage : void 0,
+		messageCounts,
+		toolUsage,
+		modelUsage: modelUsage.length ? modelUsage : void 0,
+		latency: computeLatencyStats(latencyValues),
+		...totals
+	};
+}
+const extractCostBreakdown = (usageRaw) => {
+	if (!usageRaw || typeof usageRaw !== "object") return;
+	const cost = usageRaw.cost;
+	if (!cost) return;
+	const total = asFiniteNumber(cost.total);
+	if (total === void 0 || total < 0) return;
+	return {
+		total,
+		input: asFiniteNumber(cost.input),
+		output: asFiniteNumber(cost.output),
+		cacheRead: asFiniteNumber(cost.cacheRead),
+		cacheWrite: asFiniteNumber(cost.cacheWrite)
+	};
+};
+const parseTimestamp = (entry) => {
+	const raw = entry.timestamp;
+	if (typeof raw === "string") {
+		const parsed = new Date(raw);
+		if (!Number.isNaN(parsed.valueOf())) return parsed;
+	}
+	const message = entry.message;
+	const messageTimestamp = asFiniteNumber(message?.timestamp);
+	if (messageTimestamp !== void 0) {
+		const parsed = new Date(messageTimestamp);
+		if (!Number.isNaN(parsed.valueOf())) return parsed;
+	}
+};
+const parseTranscriptEntry = (entry) => {
+	const message = entry.message;
+	if (!message || typeof message !== "object") return null;
+	const roleRaw = message.role;
+	const role = roleRaw === "user" || roleRaw === "assistant" ? roleRaw : void 0;
+	if (!role) return null;
+	const usageRaw = message.usage ?? entry.usage;
+	const usage = usageRaw ? normalizeUsage(usageRaw) ?? void 0 : void 0;
+	const provider = (typeof message.provider === "string" ? message.provider : void 0) ?? (typeof entry.provider === "string" ? entry.provider : void 0);
+	const model = (typeof message.model === "string" ? message.model : void 0) ?? (typeof entry.model === "string" ? entry.model : void 0);
+	const costBreakdown = extractCostBreakdown(usageRaw);
+	const stopReason = typeof message.stopReason === "string" ? message.stopReason : void 0;
+	const durationMs = asFiniteNumber(message.durationMs ?? entry.durationMs);
+	return {
+		message,
+		role,
+		timestamp: parseTimestamp(entry),
+		durationMs,
+		usage,
+		costTotal: costBreakdown?.total,
+		costBreakdown,
+		provider,
+		model,
+		stopReason,
+		toolNames: extractToolCallNames(message),
+		toolResultCounts: countToolResults(message)
+	};
+};
+const formatDayKey = (date) => date.toLocaleDateString("en-CA", { timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone });
+const formatUtcDayKey = (date) => `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}`;
+const getUtcQuarterHourBucketKey = (date) => {
+	const quarterIndex = Math.floor((date.getUTCHours() * 60 + date.getUTCMinutes()) / 15);
+	const utcDayKey = formatUtcDayKey(date);
+	return {
+		date: utcDayKey,
+		quarterIndex,
+		key: `${utcDayKey}::${quarterIndex}`
+	};
+};
+/**
+* Accumulate message-level counts into a bucket (daily or UTC quarter-hour).
+* Avoids duplicating the same logic for both daily and quarter-hour message counts.
+*/
+const accumulateMessageCounts = (bucket, entry, errorStopReasons) => {
+	bucket.total += entry.role === "user" || entry.role === "assistant" ? 1 : 0;
+	if (entry.role === "user") bucket.user += 1;
+	else if (entry.role === "assistant") bucket.assistant += 1;
+	bucket.toolCalls += entry.toolNames.length;
+	bucket.toolResults += entry.toolResultCounts.total;
+	bucket.errors += entry.toolResultCounts.errors;
+	if (entry.stopReason && errorStopReasons.has(entry.stopReason)) bucket.errors += 1;
+};
+const computeLatencyStats = (values) => {
+	if (!values.length) return;
+	const sorted = values.toSorted((a, b) => a - b);
+	const total = sorted.reduce((sum, v) => sum + v, 0);
+	const count = sorted.length;
+	const p95Index = Math.max(0, Math.ceil(count * .95) - 1);
+	return {
+		count,
+		avgMs: total / count,
+		p95Ms: sorted[p95Index] ?? sorted[count - 1],
+		minMs: sorted[0],
+		maxMs: sorted[count - 1]
+	};
+};
+const computeUsageTokenTotals = (usage) => {
+	const input = usage.input ?? 0;
+	const output = usage.output ?? 0;
+	const cacheRead = usage.cacheRead ?? 0;
+	const cacheWrite = usage.cacheWrite ?? 0;
+	const componentTotal = input + output + cacheRead + cacheWrite;
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		componentTotal,
+		totalTokens: usage.total ?? componentTotal
+	};
+};
+const applyUsageTotals = (totals, usage) => {
+	const usageTotals = computeUsageTokenTotals(usage);
+	totals.input += usageTotals.input;
+	totals.output += usageTotals.output;
+	totals.cacheRead += usageTotals.cacheRead;
+	totals.cacheWrite += usageTotals.cacheWrite;
+	totals.totalTokens += usageTotals.totalTokens;
+};
+const applyCostBreakdown = (totals, costBreakdown) => {
+	if (costBreakdown === void 0 || costBreakdown.total === void 0) return;
+	totals.totalCost += costBreakdown.total;
+	totals.inputCost += costBreakdown.input ?? 0;
+	totals.outputCost += costBreakdown.output ?? 0;
+	totals.cacheReadCost += costBreakdown.cacheRead ?? 0;
+	totals.cacheWriteCost += costBreakdown.cacheWrite ?? 0;
+};
+const applyCostTotal = (totals, costTotal) => {
+	if (costTotal === void 0) {
+		totals.missingCostEntries += 1;
+		return;
+	}
+	totals.totalCost += costTotal;
+};
+const isModelPricingKnown = (cost) => {
+	if (!cost) return false;
+	if (cost.tieredPricing && cost.tieredPricing.length > 0) return true;
+	return cost.input > 0 || cost.output > 0 || cost.cacheRead > 0 || cost.cacheWrite > 0;
+};
+function createUsageCostResolver(config) {
+	const cache = /* @__PURE__ */ new Map();
+	return ({ provider, model }) => {
+		const key = `${provider ?? ""}\0${model ?? ""}`;
+		if (cache.has(key)) return cache.get(key);
+		const cost = resolveModelCostConfig({
+			provider,
+			model,
+			config
+		});
+		cache.set(key, cost);
+		return cost;
+	};
+}
+async function canReadJsonlFromOffset(filePath, startOffset) {
+	if (startOffset <= 0) return true;
+	const handle = await fs.promises.open(filePath, "r").catch(() => null);
+	if (!handle) return false;
+	try {
+		const buffer = Buffer.alloc(1);
+		return (await handle.read(buffer, 0, 1, startOffset - 1)).bytesRead === 1 && buffer[0] === 10;
+	} finally {
+		await handle.close().catch(() => void 0);
+	}
+}
+async function* readJsonlRecords(filePath, startOffset = 0, endOffset) {
+	if (endOffset !== void 0 && endOffset <= startOffset) return;
+	const streamOptions = {
+		encoding: "utf-8",
+		start: Math.max(0, startOffset)
+	};
+	if (endOffset !== void 0) streamOptions.end = endOffset - 1;
+	const fileStream = fs.createReadStream(filePath, streamOptions);
+	const rl = readline.createInterface({
+		input: fileStream,
+		crlfDelay: Infinity
+	});
+	try {
+		for await (const line of rl) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			try {
+				const parsed = JSON.parse(trimmed);
+				if (!parsed || typeof parsed !== "object") continue;
+				yield parsed;
+			} catch {}
+		}
+	} finally {
+		rl.close();
+		fileStream.destroy();
+	}
+}
+async function scanTranscriptFile(params) {
+	const resolveCost = params.resolveCost ?? createUsageCostResolver(params.config);
+	for await (const parsed of readJsonlRecords(params.filePath, params.startOffset, params.endOffset)) {
+		const entry = parseTranscriptEntry(parsed);
+		if (!entry) continue;
+		if (entry.usage) {
+			const cost = resolveCost({
+				provider: entry.provider,
+				model: entry.model
+			});
+			if (cost?.tieredPricing && cost.tieredPricing.length > 0) {
+				entry.costTotal = estimateUsageCost({
+					usage: entry.usage,
+					cost
+				});
+				entry.costBreakdown = void 0;
+			} else if (!isModelPricingKnown(cost) && (entry.costTotal === void 0 || entry.costTotal === 0) && computeUsageTokenTotals(entry.usage).totalTokens > 0) {
+				entry.costTotal = void 0;
+				entry.costBreakdown = void 0;
+			} else if (entry.costTotal === void 0) entry.costTotal = estimateUsageCost({
+				usage: entry.usage,
+				cost
+			});
+		}
+		params.onEntry(entry);
+	}
+}
+async function scanUsageFile(params) {
+	await scanTranscriptFile({
+		filePath: params.filePath,
+		config: params.config,
+		resolveCost: params.resolveCost,
+		startOffset: params.startOffset,
+		endOffset: params.endOffset,
+		onEntry: (entry) => {
+			if (!entry.usage) return;
+			params.onEntry({
+				usage: entry.usage,
+				costTotal: entry.costTotal,
+				costBreakdown: entry.costBreakdown,
+				provider: entry.provider,
+				model: entry.model,
+				timestamp: entry.timestamp
+			});
+		}
+	});
+}
+function resolveExistingUsageSessionFile(params) {
+	const candidate = params.sessionFile ?? (params.sessionId ? resolveSessionFilePath(params.sessionId, params.sessionEntry, { agentId: params.agentId }) : void 0);
+	if (candidate && fs.existsSync(candidate)) return candidate;
+	const sessionId = params.sessionId?.trim();
+	if (!sessionId) return candidate;
+	try {
+		const sessionsDir = candidate ? path.dirname(candidate) : resolveSessionTranscriptsDirForAgent(params.agentId);
+		const baseFileName = `${sessionId}.jsonl`;
+		const entries = fs.readdirSync(sessionsDir, { withFileTypes: true }).filter((entry) => {
+			return entry.isFile() && (entry.name === baseFileName || entry.name.startsWith(`${baseFileName}.reset.`) || entry.name.startsWith(`${baseFileName}.deleted.`));
+		});
+		const primary = entries.find((entry) => entry.name === baseFileName);
+		if (primary) return path.join(sessionsDir, primary.name);
+		const latestArchive = entries.filter((entry) => isSessionArchiveArtifactName(entry.name)).map((entry) => entry.name).toSorted((a, b) => {
+			const tsA = parseSessionArchiveTimestamp(a, "deleted") ?? parseSessionArchiveTimestamp(a, "reset") ?? 0;
+			return (parseSessionArchiveTimestamp(b, "deleted") ?? parseSessionArchiveTimestamp(b, "reset") ?? 0) - tsA || b.localeCompare(a);
+		})[0];
+		return latestArchive ? path.join(sessionsDir, latestArchive) : candidate;
+	} catch {
+		return candidate;
+	}
+}
+async function loadCostUsageSummary(params) {
+	const now = /* @__PURE__ */ new Date();
+	let sinceTime;
+	let untilTime;
+	if (params?.startMs !== void 0 && params?.endMs !== void 0) {
+		sinceTime = params.startMs;
+		untilTime = params.endMs;
+	} else {
+		const days = Math.max(1, Math.floor(params?.days ?? 30));
+		const since = new Date(now);
+		since.setDate(since.getDate() - (days - 1));
+		sinceTime = since.getTime();
+		untilTime = now.getTime();
+	}
+	const dailyMap = /* @__PURE__ */ new Map();
+	const totals = emptyTotals();
+	const resolveCost = createUsageCostResolver(params?.config);
+	const files = await listUsageCountedTranscriptFileStats(params?.agentId, { minMtimeMs: sinceTime });
+	for (const file of files) await scanUsageFile({
+		filePath: file.filePath,
+		config: params?.config,
+		resolveCost,
+		onEntry: (entry) => {
+			const ts = entry.timestamp?.getTime();
+			if (!ts || ts < sinceTime || ts > untilTime) return;
+			const dayKey = formatDayKey(entry.timestamp ?? now);
+			const bucket = dailyMap.get(dayKey) ?? emptyTotals();
+			applyUsageTotals(bucket, entry.usage);
+			if (entry.costBreakdown?.total !== void 0) applyCostBreakdown(bucket, entry.costBreakdown);
+			else applyCostTotal(bucket, entry.costTotal);
+			dailyMap.set(dayKey, bucket);
+			applyUsageTotals(totals, entry.usage);
+			if (entry.costBreakdown?.total !== void 0) applyCostBreakdown(totals, entry.costBreakdown);
+			else applyCostTotal(totals, entry.costTotal);
+		}
+	});
+	const daily = Array.from(dailyMap.entries()).map(([date, bucket]) => Object.assign({ date }, bucket)).toSorted((a, b) => a.date.localeCompare(b.date));
+	const days = Math.ceil((untilTime - sinceTime) / (1440 * 60 * 1e3)) + 1;
+	return {
+		updatedAt: Date.now(),
+		days,
+		daily,
+		totals
+	};
+}
+async function scanUsageFileForCache(params) {
+	const pricingFingerprint = resolveUsageCostPricingFingerprint(params.config);
+	const appendOnlyPreviousCandidate = params.previous && params.previous.filePath === params.file.filePath && params.previous.size > 0 && params.previous.size < params.file.size && params.previous.pricingFingerprint === pricingFingerprint && params.previous.mtimeMs <= params.file.mtimeMs ? params.previous : void 0;
+	const appendOnlyPrevious = appendOnlyPreviousCandidate && (!params.includeSessionSummary || appendOnlyPreviousCandidate.transcriptEntries) ? appendOnlyPreviousCandidate : void 0;
+	const totals = emptyTotals();
+	const usageEntries = [];
+	const shouldTrackTranscriptEntries = params.includeSessionSummary || Boolean(appendOnlyPrevious?.transcriptEntries);
+	const transcriptEntries = shouldTrackTranscriptEntries ? [] : void 0;
+	let parsedRecords = 0;
+	let countedRecords = 0;
+	const startOffset = appendOnlyPrevious && await canReadJsonlFromOffset(params.file.filePath, appendOnlyPrevious.size) ? appendOnlyPrevious.size : void 0;
+	await scanTranscriptFile({
+		filePath: params.file.filePath,
+		config: params.config,
+		resolveCost: params.resolveCost,
+		startOffset,
+		endOffset: params.file.size,
+		onEntry: (entry) => {
+			const ts = entry.timestamp?.getTime();
+			let entryTotals;
+			if (entry.usage) {
+				parsedRecords += 1;
+				entryTotals = emptyTotals();
+				applyUsageTotals(entryTotals, entry.usage);
+				if (entry.costBreakdown?.total !== void 0) applyCostBreakdown(entryTotals, entry.costBreakdown);
+				else applyCostTotal(entryTotals, entry.costTotal);
+				addTotals(totals, entryTotals);
+				if (ts !== void 0) {
+					countedRecords += 1;
+					usageEntries.push({
+						timestamp: ts,
+						provider: entry.provider,
+						model: entry.model,
+						...entryTotals
+					});
+				}
+			}
+			transcriptEntries?.push({
+				timestamp: ts,
+				role: entry.role,
+				durationMs: entry.durationMs,
+				provider: entry.provider,
+				model: entry.model,
+				stopReason: entry.stopReason,
+				toolNames: entry.toolNames,
+				toolResultCounts: entry.toolResultCounts,
+				usageTotals: entryTotals ? cloneTotals(entryTotals) : void 0
+			});
+		}
+	});
+	const sessionId = parseUsageCountedSessionIdFromFileName(path.basename(params.file.filePath)) ?? void 0;
+	const combinedTranscriptEntries = shouldTrackTranscriptEntries ? [...(appendOnlyPrevious && startOffset !== void 0 ? appendOnlyPrevious.transcriptEntries : void 0) ?? [], ...transcriptEntries ?? []] : void 0;
+	const sessionSummary = combinedTranscriptEntries && (params.includeSessionSummary || appendOnlyPrevious?.sessionSummary) ? buildSessionCostSummaryFromCacheEntry({
+		entry: {
+			filePath: params.file.filePath,
+			size: params.file.size,
+			mtimeMs: params.file.mtimeMs,
+			pricingFingerprint,
+			scannedAt: Date.now(),
+			parsedRecords,
+			countedRecords,
+			usageEntries,
+			transcriptEntries: combinedTranscriptEntries,
+			totals,
+			sessionId
+		},
+		sessionId,
+		sessionFile: params.file.filePath,
+		startMs: Number.NEGATIVE_INFINITY,
+		endMs: Number.POSITIVE_INFINITY
+	}) ?? void 0 : void 0;
+	if (appendOnlyPrevious && startOffset !== void 0) {
+		const previousTotals = cloneTotals(appendOnlyPrevious.totals);
+		addTotals(previousTotals, totals);
+		return {
+			...appendOnlyPrevious,
+			size: params.file.size,
+			mtimeMs: params.file.mtimeMs,
+			pricingFingerprint,
+			scannedAt: Date.now(),
+			parsedRecords: appendOnlyPrevious.parsedRecords + parsedRecords,
+			countedRecords: appendOnlyPrevious.countedRecords + countedRecords,
+			usageEntries: [...appendOnlyPrevious.usageEntries, ...usageEntries],
+			transcriptEntries: combinedTranscriptEntries,
+			totals: previousTotals,
+			sessionSummary
+		};
+	}
+	return {
+		filePath: params.file.filePath,
+		size: params.file.size,
+		mtimeMs: params.file.mtimeMs,
+		pricingFingerprint,
+		scannedAt: Date.now(),
+		parsedRecords,
+		countedRecords,
+		usageEntries,
+		transcriptEntries: combinedTranscriptEntries,
+		totals,
+		sessionId,
+		sessionSummary
+	};
+}
+async function refreshCostUsageCacheForPath(params) {
+	const cachePath = params?.cachePath ?? resolveUsageCostCachePath(params?.agentId);
+	const lock = await acquireUsageCostCacheRefreshLock(cachePath);
+	if (!lock.acquired) return "busy";
+	try {
+		const pricingFingerprint = resolveUsageCostPricingFingerprint(params?.config);
+		const cache = await readUsageCostCache(cachePath);
+		const files = await listUsageCountedTranscriptFiles(params?.agentId, { sessionsDir: params?.sessionsDir });
+		const sessionSummaryFiles = new Set(params?.sessionFiles ?? []);
+		const refreshStartMs = params?.startMs;
+		const refreshFiles = sessionSummaryFiles.size > 0 ? files.filter((file) => sessionSummaryFiles.has(file.filePath)) : refreshStartMs === void 0 ? files : files.filter((file) => file.mtimeMs >= refreshStartMs);
+		const livePaths = new Set(files.map((file) => file.filePath));
+		for (const filePath of Object.keys(cache.files)) if (!livePaths.has(filePath)) delete cache.files[filePath];
+		const maxFiles = params?.maxFiles !== void 0 && Number.isFinite(params.maxFiles) && params.maxFiles > 0 ? Math.floor(params.maxFiles) : void 0;
+		const staleFiles = getUsageCostStaleFiles({
+			cache,
+			files: refreshFiles,
+			pricingFingerprint,
+			sessionSummaryFiles
+		}).toSorted((a, b) => {
+			return (sessionSummaryFiles.has(a.filePath) ? 0 : 1) - (sessionSummaryFiles.has(b.filePath) ? 0 : 1) || a.size - b.size || a.filePath.localeCompare(b.filePath);
+		}).slice(0, maxFiles);
+		const resolveCost = createUsageCostResolver(params?.config);
+		for (const file of staleFiles) {
+			cache.files[file.filePath] = await scanUsageFileForCache({
+				file,
+				config: params?.config,
+				resolveCost,
+				previous: cache.files[file.filePath],
+				includeSessionSummary: sessionSummaryFiles.has(file.filePath)
+			});
+			cache.updatedAt = Date.now();
+			await writeUsageCostCache(cachePath, cache);
+		}
+		cache.updatedAt = Date.now();
+		await writeUsageCostCache(cachePath, cache);
+		return "refreshed";
+	} finally {
+		await lock.release();
+	}
+}
+async function refreshCostUsageCache(params) {
+	return await refreshCostUsageCacheForPath(params);
+}
+async function loadCostUsageSummaryFromCache(params) {
+	const cachePath = resolveUsageCostCachePath(params.agentId);
+	const pricingFingerprint = resolveUsageCostPricingFingerprint(params.config);
+	let [cache, files] = await Promise.all([readUsageCostCache(cachePath), listUsageCountedTranscriptFiles(params.agentId)]);
+	const staleFiles = getUsageCostStaleFiles({
+		cache,
+		files,
+		pricingFingerprint
+	});
+	if (params.requestRefresh !== false && staleFiles.length > 0) {
+		const cachedFiles = countUsableUsageCostCacheFiles({
+			cache,
+			files,
+			pricingFingerprint
+		});
+		if (params.refreshMode === "sync-when-empty" && cachedFiles === 0) {
+			const result = await refreshCostUsageCache({
+				config: params.config,
+				agentId: params.agentId,
+				startMs: params.startMs
+			});
+			[cache, files] = await Promise.all([readUsageCostCache(cachePath), listUsageCountedTranscriptFiles(params.agentId)]);
+			if (result === "refreshed") {
+				if (getUsageCostStaleFiles({
+					cache,
+					files,
+					pricingFingerprint
+				}).length > 0) requestCostUsageCacheRefresh({
+					config: params.config,
+					agentId: params.agentId
+				});
+			}
+		} else requestCostUsageCacheRefresh({
+			config: params.config,
+			agentId: params.agentId
+		});
+	}
+	const refreshRunning = await isUsageCostCacheRefreshRunning(cachePath);
+	return buildCostUsageSummaryFromCache({
+		cache,
+		files,
+		startMs: params.startMs,
+		endMs: params.endMs,
+		pricingFingerprint,
+		refreshing: usageCostRefreshes.has(cachePath) || refreshRunning
+	});
+}
+async function loadSessionCostSummaryFromCache(params) {
+	const cachePath = resolveUsageCostCachePath(params.agentId);
+	const pricingFingerprint = resolveUsageCostPricingFingerprint(params.config);
+	let [cache, stats] = await Promise.all([readUsageCostCache(cachePath), fs.promises.stat(params.sessionFile).catch(() => null)]);
+	let file = stats ? {
+		filePath: params.sessionFile,
+		size: stats.size,
+		mtimeMs: stats.mtimeMs
+	} : void 0;
+	let entry = cache.files[params.sessionFile];
+	let stale = !file || !isUsageCostCacheEntryFresh({
+		entry,
+		file,
+		pricingFingerprint,
+		requireSessionSummary: true
+	});
+	let refreshRequested = false;
+	if (params.requestRefresh !== false && stale) if (params.refreshMode === "sync-when-empty") if (await refreshCostUsageCache({
+		config: params.config,
+		agentId: params.agentId,
+		sessionFiles: [params.sessionFile]
+	}) === "refreshed") {
+		[cache, stats] = await Promise.all([readUsageCostCache(cachePath), fs.promises.stat(params.sessionFile).catch(() => null)]);
+		file = stats ? {
+			filePath: params.sessionFile,
+			size: stats.size,
+			mtimeMs: stats.mtimeMs
+		} : void 0;
+		entry = cache.files[params.sessionFile];
+		stale = !file || !isUsageCostCacheEntryFresh({
+			entry,
+			file,
+			pricingFingerprint,
+			requireSessionSummary: true
+		});
+	} else {
+		requestCostUsageCacheRefresh({
+			config: params.config,
+			agentId: params.agentId,
+			sessionFiles: [params.sessionFile]
+		});
+		refreshRequested = true;
+	}
+	else {
+		requestCostUsageCacheRefresh({
+			config: params.config,
+			agentId: params.agentId,
+			sessionFiles: [params.sessionFile]
+		});
+		refreshRequested = true;
+	}
+	const refreshRunning = usageCostRefreshes.has(cachePath) || await isUsageCostCacheRefreshRunning(cachePath);
+	let summary = stale ? null : entry?.sessionSummary ?? null;
+	if (!summary && params.refreshMode === "sync-when-empty") summary = await loadSessionCostSummary({
+		sessionId: params.sessionId,
+		sessionEntry: params.sessionEntry,
+		sessionFile: params.sessionFile,
+		config: params.config,
+		agentId: params.agentId,
+		startMs: params.startMs,
+		endMs: params.endMs
+	});
+	if (summary && params.startMs !== void 0 && params.endMs !== void 0 && !isSessionSummaryContainedInRange(summary, params.startMs, params.endMs)) summary = entry ? buildSessionCostSummaryFromCacheEntry({
+		entry,
+		sessionId: params.sessionId,
+		sessionFile: params.sessionFile,
+		startMs: params.startMs,
+		endMs: params.endMs
+	}) : params.refreshMode === "sync-when-empty" ? await loadSessionCostSummary({
+		sessionId: params.sessionId,
+		sessionEntry: params.sessionEntry,
+		sessionFile: params.sessionFile,
+		config: params.config,
+		agentId: params.agentId,
+		startMs: params.startMs,
+		endMs: params.endMs
+	}) : null;
+	return {
+		summary,
+		cacheStatus: {
+			status: stale ? refreshRunning || refreshRequested ? "refreshing" : summary ? "partial" : "stale" : "fresh",
+			cachedFiles: stale ? 0 : 1,
+			pendingFiles: stale ? 1 : 0,
+			staleFiles: stale ? 1 : 0,
+			refreshedAt: cache.updatedAt || void 0
+		}
+	};
+}
+function requestCostUsageCacheRefresh(params) {
+	const cachePath = resolveUsageCostCachePath(params?.agentId);
+	const existing = usageCostRefreshes.get(cachePath);
+	if (existing) {
+		mergeUsageCostRefreshRequest(existing, params);
+		return;
+	}
+	const state = {
+		agentId: params?.agentId,
+		cachePath,
+		config: params?.config,
+		fullRefreshRequested: false,
+		pendingSessionFiles: /* @__PURE__ */ new Set(),
+		running: false,
+		sessionsDir: path.dirname(cachePath)
+	};
+	mergeUsageCostRefreshRequest(state, params);
+	usageCostRefreshes.set(cachePath, state);
+	scheduleUsageCostRefresh(cachePath, state);
+}
+function mergeUsageCostRefreshRequest(state, params) {
+	if (params?.config) state.config = params.config;
+	if (params?.agentId) state.agentId = params.agentId;
+	if (!params?.sessionFiles) {
+		state.fullRefreshRequested = true;
+		return;
+	}
+	for (const sessionFile of params.sessionFiles) state.pendingSessionFiles.add(sessionFile);
+}
+function scheduleUsageCostRefresh(refreshKey, state, delayMs = 0) {
+	if (state.running || state.timer) return;
+	const timer = setTimeout(() => {
+		state.timer = void 0;
+		runQueuedUsageCostRefresh(refreshKey, state);
+	}, delayMs);
+	timer.unref?.();
+	state.timer = timer;
+}
+async function runQueuedUsageCostRefresh(refreshKey, state) {
+	state.running = true;
+	let retryDelayMs = 0;
+	try {
+		while (state.fullRefreshRequested || state.pendingSessionFiles.size > 0) {
+			const fullRefreshRequested = state.fullRefreshRequested;
+			const sessionFiles = fullRefreshRequested ? [] : [...state.pendingSessionFiles];
+			if (!fullRefreshRequested) state.pendingSessionFiles.clear();
+			state.fullRefreshRequested = false;
+			if (await refreshCostUsageCacheForPath({
+				cachePath: state.cachePath,
+				config: state.config,
+				agentId: state.agentId,
+				sessionsDir: state.sessionsDir,
+				sessionFiles: fullRefreshRequested ? void 0 : sessionFiles
+			}) === "busy") {
+				if (fullRefreshRequested) state.fullRefreshRequested = true;
+				else for (const sessionFile of sessionFiles) state.pendingSessionFiles.add(sessionFile);
+				retryDelayMs = 50;
+				break;
+			}
+		}
+	} catch (error) {
+		logger.warn(`background refresh failed: ${formatErrorMessage(error)}`, { error });
+	} finally {
+		state.running = false;
+		if (state.fullRefreshRequested || state.pendingSessionFiles.size > 0) scheduleUsageCostRefresh(refreshKey, state, retryDelayMs);
+		else usageCostRefreshes.delete(refreshKey);
+	}
+}
+/**
+* Scan all transcript files to discover sessions not in the session store.
+* Returns basic metadata for each discovered session.
+*/
+async function discoverAllSessions(params) {
+	const files = await listUsageCountedTranscriptFileStats(params?.agentId, { minMtimeMs: params?.startMs });
+	const discovered = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const filePath = file.filePath;
+		const fileName = path.basename(filePath);
+		const sessionId = parseUsageCountedSessionIdFromFileName(fileName);
+		if (!sessionId) continue;
+		const isPrimaryTranscript = isPrimarySessionTranscriptFileName(fileName);
+		let firstUserMessage;
+		if (params?.includeFirstUserMessage !== false) try {
+			for await (const parsed of readJsonlRecords(filePath)) try {
+				const message = parsed.message;
+				if (message?.role === "user") {
+					const content = message.content;
+					if (typeof content === "string") firstUserMessage = content.slice(0, 100);
+					else if (Array.isArray(content)) {
+						for (const block of content) if (typeof block === "object" && block && block.type === "text") {
+							const text = block.text;
+							if (typeof text === "string") firstUserMessage = text.slice(0, 100);
+							break;
+						}
+					}
+					break;
+				}
+			} catch {}
+		} catch {}
+		const existing = discovered.get(sessionId);
+		const existingIsPrimary = existing ? isPrimarySessionTranscriptFileName(path.basename(existing.sessionFile)) : false;
+		if (!existing || isPrimaryTranscript && !existingIsPrimary || isPrimaryTranscript === existingIsPrimary && file.mtimeMs >= existing.mtime) {
+			discovered.set(sessionId, {
+				sessionId,
+				sessionFile: filePath,
+				mtime: file.mtimeMs,
+				firstUserMessage: firstUserMessage ?? existing?.firstUserMessage
+			});
+			continue;
+		}
+		if (!existing.firstUserMessage && firstUserMessage) {
+			existing.firstUserMessage = firstUserMessage;
+			discovered.set(sessionId, existing);
+		}
+	}
+	return Array.from(discovered.values()).toSorted((a, b) => b.mtime - a.mtime);
+}
+async function loadSessionCostSummary(params) {
+	const sessionFile = resolveExistingUsageSessionFile(params);
+	if (!sessionFile || !fs.existsSync(sessionFile)) return null;
+	const totals = emptyTotals();
+	let firstActivity;
+	let lastActivity;
+	const activityDatesSet = /* @__PURE__ */ new Set();
+	const dailyMap = /* @__PURE__ */ new Map();
+	const dailyMessageMap = /* @__PURE__ */ new Map();
+	const utcQuarterHourMessageMap = /* @__PURE__ */ new Map();
+	const utcQuarterHourTokenMap = /* @__PURE__ */ new Map();
+	const dailyLatencyMap = /* @__PURE__ */ new Map();
+	const dailyModelUsageMap = /* @__PURE__ */ new Map();
+	const messageCounts = {
+		total: 0,
+		user: 0,
+		assistant: 0,
+		toolCalls: 0,
+		toolResults: 0,
+		errors: 0
+	};
+	const toolUsageMap = /* @__PURE__ */ new Map();
+	const modelUsageMap = /* @__PURE__ */ new Map();
+	const errorStopReasons = new Set([
+		"error",
+		"aborted",
+		"timeout"
+	]);
+	const latencyValues = [];
+	let lastUserTimestamp;
+	const MAX_LATENCY_MS = 720 * 60 * 1e3;
+	const resolveCost = createUsageCostResolver(params.config);
+	await scanTranscriptFile({
+		filePath: sessionFile,
+		config: params.config,
+		resolveCost,
+		onEntry: (entry) => {
+			const ts = entry.timestamp?.getTime();
+			if (params.startMs !== void 0 && ts !== void 0 && ts < params.startMs) return;
+			if (params.endMs !== void 0 && ts !== void 0 && ts > params.endMs) return;
+			if (ts !== void 0) {
+				if (!firstActivity || ts < firstActivity) firstActivity = ts;
+				if (!lastActivity || ts > lastActivity) lastActivity = ts;
+			}
+			if (entry.role === "user") {
+				messageCounts.user += 1;
+				messageCounts.total += 1;
+				if (entry.timestamp) lastUserTimestamp = entry.timestamp.getTime();
+			}
+			if (entry.role === "assistant") {
+				messageCounts.assistant += 1;
+				messageCounts.total += 1;
+				const ts = entry.timestamp?.getTime();
+				if (ts !== void 0) {
+					const latencyMs = entry.durationMs ?? (lastUserTimestamp !== void 0 ? Math.max(0, ts - lastUserTimestamp) : void 0);
+					if (latencyMs !== void 0 && Number.isFinite(latencyMs) && latencyMs <= MAX_LATENCY_MS) {
+						latencyValues.push(latencyMs);
+						const dayKey = formatDayKey(entry.timestamp ?? new Date(ts));
+						const dailyLatencies = dailyLatencyMap.get(dayKey) ?? [];
+						dailyLatencies.push(latencyMs);
+						dailyLatencyMap.set(dayKey, dailyLatencies);
+					}
+				}
+			}
+			if (entry.toolNames.length > 0) {
+				messageCounts.toolCalls += entry.toolNames.length;
+				for (const name of entry.toolNames) toolUsageMap.set(name, (toolUsageMap.get(name) ?? 0) + 1);
+			}
+			if (entry.toolResultCounts.total > 0) {
+				messageCounts.toolResults += entry.toolResultCounts.total;
+				messageCounts.errors += entry.toolResultCounts.errors;
+			}
+			if (entry.stopReason && errorStopReasons.has(entry.stopReason)) messageCounts.errors += 1;
+			if (entry.timestamp) {
+				const dayKey = formatDayKey(entry.timestamp);
+				activityDatesSet.add(dayKey);
+				const daily = dailyMessageMap.get(dayKey) ?? {
+					date: dayKey,
+					total: 0,
+					user: 0,
+					assistant: 0,
+					toolCalls: 0,
+					toolResults: 0,
+					errors: 0
+				};
+				accumulateMessageCounts(daily, entry, errorStopReasons);
+				dailyMessageMap.set(dayKey, daily);
+				const quarterBucket = getUtcQuarterHourBucketKey(entry.timestamp);
+				const utcQuarterHour = utcQuarterHourMessageMap.get(quarterBucket.key) ?? {
+					date: quarterBucket.date,
+					quarterIndex: quarterBucket.quarterIndex,
+					total: 0,
+					user: 0,
+					assistant: 0,
+					toolCalls: 0,
+					toolResults: 0,
+					errors: 0
+				};
+				accumulateMessageCounts(utcQuarterHour, entry, errorStopReasons);
+				utcQuarterHourMessageMap.set(quarterBucket.key, utcQuarterHour);
+			}
+			if (!entry.usage) return;
+			applyUsageTotals(totals, entry.usage);
+			if (entry.costBreakdown?.total !== void 0) applyCostBreakdown(totals, entry.costBreakdown);
+			else applyCostTotal(totals, entry.costTotal);
+			if (entry.timestamp) {
+				const dayKey = formatDayKey(entry.timestamp);
+				const entryTokenTotals = computeUsageTokenTotals(entry.usage);
+				const entryTokens = entryTokenTotals.componentTotal;
+				const entryCost = entry.costBreakdown?.total ?? (entry.costBreakdown ? (entry.costBreakdown.input ?? 0) + (entry.costBreakdown.output ?? 0) + (entry.costBreakdown.cacheRead ?? 0) + (entry.costBreakdown.cacheWrite ?? 0) : entry.costTotal ?? 0);
+				const quarterBucket = getUtcQuarterHourBucketKey(entry.timestamp);
+				const utcQuarterHourToken = utcQuarterHourTokenMap.get(quarterBucket.key) ?? {
+					date: quarterBucket.date,
+					quarterIndex: quarterBucket.quarterIndex,
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					totalTokens: 0,
+					totalCost: 0
+				};
+				utcQuarterHourToken.input += entryTokenTotals.input;
+				utcQuarterHourToken.output += entryTokenTotals.output;
+				utcQuarterHourToken.cacheRead += entryTokenTotals.cacheRead;
+				utcQuarterHourToken.cacheWrite += entryTokenTotals.cacheWrite;
+				utcQuarterHourToken.totalTokens += entryTokenTotals.totalTokens;
+				utcQuarterHourToken.totalCost += entryCost;
+				utcQuarterHourTokenMap.set(quarterBucket.key, utcQuarterHourToken);
+				const existing = dailyMap.get(dayKey) ?? {
+					tokens: 0,
+					cost: 0
+				};
+				dailyMap.set(dayKey, {
+					tokens: existing.tokens + entryTokens,
+					cost: existing.cost + entryCost
+				});
+				if (entry.provider || entry.model) {
+					const modelKey = `${dayKey}::${entry.provider ?? "unknown"}::${entry.model ?? "unknown"}`;
+					const dailyModel = dailyModelUsageMap.get(modelKey) ?? {
+						date: dayKey,
+						provider: entry.provider,
+						model: entry.model,
+						tokens: 0,
+						cost: 0,
+						count: 0
+					};
+					dailyModel.tokens += entryTokens;
+					dailyModel.cost += entryCost;
+					dailyModel.count += 1;
+					dailyModelUsageMap.set(modelKey, dailyModel);
+				}
+			}
+			if (entry.provider || entry.model) {
+				const key = `${entry.provider ?? "unknown"}::${entry.model ?? "unknown"}`;
+				const existing = modelUsageMap.get(key) ?? {
+					provider: entry.provider,
+					model: entry.model,
+					count: 0,
+					totals: emptyTotals()
+				};
+				existing.count += 1;
+				applyUsageTotals(existing.totals, entry.usage);
+				if (entry.costBreakdown?.total !== void 0) applyCostBreakdown(existing.totals, entry.costBreakdown);
+				else applyCostTotal(existing.totals, entry.costTotal);
+				modelUsageMap.set(key, existing);
+			}
+		}
+	});
+	const dailyBreakdown = Array.from(dailyMap.entries()).map(([date, data]) => ({
+		date,
+		tokens: data.tokens,
+		cost: data.cost
+	})).toSorted((a, b) => a.date.localeCompare(b.date));
+	const dailyMessageCounts = Array.from(dailyMessageMap.values()).toSorted((a, b) => a.date.localeCompare(b.date));
+	const utcQuarterHourMessageCounts = Array.from(utcQuarterHourMessageMap.values()).toSorted((a, b) => a.date.localeCompare(b.date) || a.quarterIndex - b.quarterIndex);
+	const utcQuarterHourTokenUsage = Array.from(utcQuarterHourTokenMap.values()).toSorted((a, b) => a.date.localeCompare(b.date) || a.quarterIndex - b.quarterIndex);
+	const dailyLatency = Array.from(dailyLatencyMap.entries()).map(([date, values]) => {
+		const stats = computeLatencyStats(values);
+		if (!stats) return null;
+		return Object.assign({ date }, stats);
+	}).filter((entry) => Boolean(entry)).toSorted((a, b) => a.date.localeCompare(b.date));
+	const dailyModelUsage = Array.from(dailyModelUsageMap.values()).toSorted((a, b) => a.date.localeCompare(b.date) || b.cost - a.cost);
+	const toolUsage = toolUsageMap.size ? {
+		totalCalls: Array.from(toolUsageMap.values()).reduce((sum, count) => sum + count, 0),
+		uniqueTools: toolUsageMap.size,
+		tools: Array.from(toolUsageMap.entries()).map(([name, count]) => ({
+			name,
+			count
+		})).toSorted((a, b) => b.count - a.count)
+	} : void 0;
+	const modelUsage = modelUsageMap.size ? Array.from(modelUsageMap.values()).toSorted((a, b) => {
+		const costDiff = (b.totals?.totalCost ?? 0) - (a.totals?.totalCost ?? 0);
+		if (costDiff !== 0) return costDiff;
+		return (b.totals?.totalTokens ?? 0) - (a.totals?.totalTokens ?? 0);
+	}) : void 0;
+	return {
+		sessionId: params.sessionId,
+		sessionFile,
+		firstActivity,
+		lastActivity,
+		durationMs: firstActivity !== void 0 && lastActivity !== void 0 ? Math.max(0, lastActivity - firstActivity) : void 0,
+		activityDates: Array.from(activityDatesSet).toSorted(),
+		dailyBreakdown,
+		dailyMessageCounts,
+		utcQuarterHourMessageCounts: utcQuarterHourMessageCounts.length ? utcQuarterHourMessageCounts : void 0,
+		utcQuarterHourTokenUsage: utcQuarterHourTokenUsage.length ? utcQuarterHourTokenUsage : void 0,
+		dailyLatency: dailyLatency.length ? dailyLatency : void 0,
+		dailyModelUsage: dailyModelUsage.length ? dailyModelUsage : void 0,
+		messageCounts,
+		toolUsage,
+		modelUsage,
+		latency: computeLatencyStats(latencyValues),
+		...totals
+	};
+}
+async function loadSessionUsageTimeSeries(params) {
+	const sessionFile = resolveExistingUsageSessionFile(params);
+	if (!sessionFile || !fs.existsSync(sessionFile)) return null;
+	const points = [];
+	let cumulativeTokens = 0;
+	let cumulativeCost = 0;
+	const resolveCost = createUsageCostResolver(params.config);
+	await scanUsageFile({
+		filePath: sessionFile,
+		config: params.config,
+		resolveCost,
+		onEntry: (entry) => {
+			const ts = entry.timestamp?.getTime();
+			if (!ts) return;
+			const { input, output, cacheRead, cacheWrite, totalTokens } = computeUsageTokenTotals(entry.usage);
+			const cost = entry.costTotal ?? 0;
+			cumulativeTokens += totalTokens;
+			cumulativeCost += cost;
+			points.push({
+				timestamp: ts,
+				input,
+				output,
+				cacheRead,
+				cacheWrite,
+				totalTokens,
+				cost,
+				cumulativeTokens,
+				cumulativeCost
+			});
+		}
+	});
+	const sortedPoints = points.toSorted((a, b) => a.timestamp - b.timestamp);
+	if (params.maxPoints !== void 0 && params.maxPoints !== null) {
+		if (!Number.isFinite(params.maxPoints) || params.maxPoints <= 0) return {
+			sessionId: params.sessionId,
+			points: []
+		};
+	}
+	const maxPoints = params.maxPoints ?? 100;
+	if (sortedPoints.length > maxPoints) {
+		const step = Math.ceil(sortedPoints.length / maxPoints);
+		const downsampled = [];
+		let downsampledCumulativeTokens = 0;
+		let downsampledCumulativeCost = 0;
+		for (let i = 0; i < sortedPoints.length; i += step) {
+			const bucket = sortedPoints.slice(i, i + step);
+			const bucketLast = bucket[bucket.length - 1];
+			if (!bucketLast) continue;
+			let bucketInput = 0;
+			let bucketOutput = 0;
+			let bucketCacheRead = 0;
+			let bucketCacheWrite = 0;
+			let bucketTotalTokens = 0;
+			let bucketCost = 0;
+			for (const point of bucket) {
+				bucketInput += point.input;
+				bucketOutput += point.output;
+				bucketCacheRead += point.cacheRead;
+				bucketCacheWrite += point.cacheWrite;
+				bucketTotalTokens += point.totalTokens;
+				bucketCost += point.cost;
+			}
+			downsampledCumulativeTokens += bucketTotalTokens;
+			downsampledCumulativeCost += bucketCost;
+			downsampled.push({
+				timestamp: bucketLast.timestamp,
+				input: bucketInput,
+				output: bucketOutput,
+				cacheRead: bucketCacheRead,
+				cacheWrite: bucketCacheWrite,
+				totalTokens: bucketTotalTokens,
+				cost: bucketCost,
+				cumulativeTokens: downsampledCumulativeTokens,
+				cumulativeCost: downsampledCumulativeCost
+			});
+		}
+		return {
+			sessionId: params.sessionId,
+			points: downsampled
+		};
+	}
+	return {
+		sessionId: params.sessionId,
+		points: sortedPoints
+	};
+}
+async function loadSessionLogs(params) {
+	const sessionFile = resolveExistingUsageSessionFile(params);
+	if (!sessionFile || !fs.existsSync(sessionFile)) return null;
+	const logs = [];
+	if (params.limit !== void 0 && params.limit !== null) {
+		if (!Number.isFinite(params.limit) || params.limit <= 0) return [];
+	}
+	const limit = params.limit ?? 50;
+	const resolveCost = createUsageCostResolver(params.config);
+	for await (const parsed of readJsonlRecords(sessionFile)) try {
+		const message = parsed.message;
+		if (!message) continue;
+		const role = message.role;
+		if (role !== "user" && role !== "assistant" && role !== "tool" && role !== "toolResult") continue;
+		const contentParts = [];
+		const toolName = normalizeOptionalString(message.toolName ?? message.tool_name ?? message.name ?? message.tool);
+		if (role === "tool" || role === "toolResult") {
+			contentParts.push(`[Tool: ${toolName ?? "tool"}]`);
+			contentParts.push("[Tool Result]");
+		}
+		const rawContent = message.content;
+		if (typeof rawContent === "string") contentParts.push(rawContent);
+		else if (Array.isArray(rawContent)) {
+			const contentText = rawContent.map((block) => {
+				if (typeof block === "string") return block;
+				const b = block;
+				if (b.type === "text" && typeof b.text === "string") return b.text;
+				if (b.type === "tool_use") return `[Tool: ${typeof b.name === "string" ? b.name : "unknown"}]`;
+				if (b.type === "tool_result") return `[Tool Result]`;
+				return "";
+			}).filter(Boolean).join("\n");
+			if (contentText) contentParts.push(contentText);
+		}
+		const rawToolCalls = message.tool_calls ?? message.toolCalls ?? message.function_call ?? message.functionCall;
+		const toolCalls = Array.isArray(rawToolCalls) ? rawToolCalls : rawToolCalls ? [rawToolCalls] : [];
+		if (toolCalls.length > 0) for (const call of toolCalls) {
+			const callObj = call;
+			const directName = typeof callObj.name === "string" ? callObj.name : void 0;
+			const fn = callObj.function;
+			const fnName = typeof fn?.name === "string" ? fn.name : void 0;
+			const name = directName ?? fnName ?? "unknown";
+			contentParts.push(`[Tool: ${name}]`);
+		}
+		let content = contentParts.join("\n").trim();
+		if (!content) continue;
+		content = stripInboundMetadata(content);
+		if (role === "user") content = stripMessageIdHints(stripEnvelope(content)).trim();
+		if (!content) continue;
+		const maxLen = 2e3;
+		if (content.length > maxLen) content = content.slice(0, maxLen) + "…";
+		let timestamp = 0;
+		if (typeof parsed.timestamp === "string") timestamp = new Date(parsed.timestamp).getTime();
+		else if (typeof message.timestamp === "number") timestamp = message.timestamp;
+		let tokens;
+		let cost;
+		if (role === "assistant") {
+			const usageRaw = message.usage;
+			const usage = normalizeUsage(usageRaw);
+			if (usage) {
+				tokens = usage.total ?? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+				const breakdown = extractCostBreakdown(usageRaw);
+				if (breakdown?.total !== void 0) cost = breakdown.total;
+				else cost = estimateUsageCost({
+					usage,
+					cost: resolveCost({
+						provider: message.provider,
+						model: message.model
+					})
+				});
+			}
+		}
+		logs.push({
+			timestamp,
+			role,
+			content,
+			tokens,
+			cost
+		});
+	} catch {}
+	const sortedLogs = logs.toSorted((a, b) => a.timestamp - b.timestamp);
+	if (sortedLogs.length > limit) return sortedLogs.slice(-limit);
+	return sortedLogs;
+}
+//#endregion
+export { loadSessionCostSummaryFromCache as a, resolveExistingUsageSessionFile as c, loadSessionCostSummary as i, loadCostUsageSummary as n, loadSessionLogs as o, loadCostUsageSummaryFromCache as r, loadSessionUsageTimeSeries as s, discoverAllSessions as t };