@loredunk/ccoach 0.1.0

package/dist/src-CKrgEaD-.js

@@ -0,0 +1,1957 @@
+import { dirname, join } from "node:path";
+import { readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+
+//#region src/window.ts
+const YMD = /^\d{4}-\d{2}-\d{2}$/;
+function localYmd(d) {
+	return new Intl.DateTimeFormat("en-CA").format(d);
+}
+function addDaysYmd(ymd, delta) {
+	const [y, m, day] = ymd.split("-").map(Number);
+	const dt = new Date(Date.UTC(y, m - 1, day + delta));
+	return dt.toISOString().slice(0, 10);
+}
+function resolveWindow(o, now) {
+	const today = localYmd(now);
+	if (o.date) {
+		if (!YMD.test(o.date)) throw new Error(`invalid --date ${o.date} (want YYYY-MM-DD)`);
+		return {
+			fromYmd: o.date,
+			toYmd: o.date,
+			desc: o.date
+		};
+	}
+	if (o.since) {
+		if (!YMD.test(o.since)) throw new Error(`invalid --since ${o.since} (want YYYY-MM-DD)`);
+		return {
+			fromYmd: o.since,
+			toYmd: today,
+			desc: `${o.since} 至 ${today}`
+		};
+	}
+	if (o.days && o.days > 0) {
+		const from = addDaysYmd(today, -(o.days - 1));
+		return {
+			fromYmd: from,
+			toYmd: today,
+			desc: `最近 ${o.days} 天 (${from} 至 ${today})`
+		};
+	}
+	return {
+		fromYmd: today,
+		toYmd: today,
+		desc: today
+	};
+}
+function inLocalRange(ts, w) {
+	const ymd = localYmd(ts);
+	return ymd >= w.fromYmd && ymd <= w.toYmd;
+}
+
+//#endregion
+//#region src/model.ts
+const emptyTokens = () => ({
+	input: 0,
+	cached_input: 0,
+	output: 0,
+	reasoning_output: 0,
+	cache_creation: 0,
+	total: 0
+});
+const REPORT_GLOSSARY = {
+	_about: "仅本机数据，不跨机器汇总；不含任何账户级配额百分比（CLI 下 rate_limits 恒为 null）。",
+	cache_hit_rate: "cached_input /（cached_input + 非缓存输入）的缓存命中率，两平台口径统一、恒在 0–1（Codex 下 input 含缓存，等价于 cached/input）；越高越省钱（重复上下文被缓存复用）。",
+	reasoning_ratio: "reasoning_output / output，推理 token 占输出的比例；偏高常意味任务被反复推理。",
+	estimated_cost_usd: "离线 best-effort fallback 估算，仅供参考、不等于实际账单。权威成本由 skill 层联网查询各模型官方定价后计算覆盖；本字段仅在未联网查价时作兜底（用内置离线 fallback 价表）。",
+	models_timeline: "每个模型的首/末出现日期（first_day/last_day，本机时区）与每日 token；用于时间感知判断：某旧模型占大头若只因新模型当时还没出现，不应判为浪费。（防 token 爆炸：列表取 token 前 10 个模型，每个 days[] 只列最近 31 天；first_day/last_day/tokens 为真实全量。repos/sources/languages 同样按 token 取前 N。）",
+	model_tokens: "每个模型的全窗口 token 分桶（input/cached_input/output/reasoning_output/cache_creation/total）+ 离线 fallback 估算成本与 priced 标记。供 skill 层按实际模型名联网查官方定价后自行计价（Claude 互斥桶 vs Codex cached⊆input 公式不同，必须分桶）。按 token 取前 10 个模型。",
+	tokens: "input/cached_input/output/reasoning_output/cache_creation/total；cached_input 是 input 的子集。",
+	prompt_signals: "仅由 user prompt 派生的数值信号（长度/结构化率/文件引用率/约束率/返工率），不含任何原文。",
+	error_signals: "工具失败率/中断数/API错误，及失败按工具与按白名单类别（git/test/build/permission/network/timeout/not-read/other）。仅由工具结果派生计数+类别，绝不含原始 stderr/输出/文件内容/命令全行（隐私红线细化，ADR 0016）。",
+	rework_signals: "编辑次数、用户事后手改率（userModified）、累计新增/删除行数（structuredPatch）。只派生计数，绝不含 diff 文本（ADR 0017）。",
+	skills: "各 skill 被调用的次数（按 attributionSkill），反映 skill 使用画像。",
+	environment: "Claude Code 版本、权限模式分布、附件数、子代理消息数——只由记录元数据派生的非敏感标签/计数（ADR 0017）。",
+	billing: "仅 Codex：按订阅 plan tier(plus/pro/…) 拆 token + 未分类桶（有 token 无 plan_type，≠确定API）。只从 rate_limits 的存在性+plan_type 标签派生 token 归类，不输出任何配额%/余额/重置时间（rate_limits 顶层仍恒 null）。confidence=spoofable-by-relay：plan_type 来自后端响应、可被中转透传或伪造，不能据此断言\"官方订阅\"（ADR 0022 D1）。",
+	codex_specific: "仅 Codex 的执行画像：effort/审批策略/沙箱/协作模式/personality/客户端身份(originators) 分布 + 压缩(compactions)/放弃回合(aborted_turns)/上下文窗口(context_window)/git 仓库身份(布尔)。全为派生计数/白名单枚举标签，collaboration_mode 仅取 mode 名、绝不读 developer_instructions 正文（ADR 0023 D1 / 0017）。",
+	claude_specific: "仅 Claude 的服务端工具计数：web 搜索/抓取请求数（usage.server_tool_use）。Claude 多数差异化信号已在 environment/skills/rework 覆盖，此处仅补 server_tool_use（ADR 0023 D2）。",
+	endpoints: "端点/计费模式检测（账户级当前快照，读本机 config）：endpoint(official|custom|unknown)+relay_suspected+auth_mode+subscription_type+billing_mode(subscription|api_or_relay|unknown)+confidence。只派生布尔/host 白名单/枚举标签，绝不存 key/token/完整 base_url URL（custom 不回显中转域名）。与 billing 块（历史 token 拆分）正交：这是\"现在怎么计费/是否走中转\"。endpoint=custom 时 plan_type 标签可能被中转伪造，billing_mode 保守判 api_or_relay（ADR 0022 D2/D3/D4）。",
+	git_habits: "git 子命令频次与评审/风险信号（如只 diff/status 不 commit）。",
+	project_management: "各仓库是否有测试/构建/CI 信号。",
+	"tools.by_name": "各工具被调用次数（仅工具名计数，如 Bash/Edit/Glob/mcp__…；不含命令行/参数）。",
+	"tools.categories": "工具类别计数 shell/web/file/search/mcp/other（纯计数，无内容）。",
+	file_languages: "按读写/编辑文件的扩展名派生的语言文件数（仅扩展名映射语言，绝不含路径/文件内容）。",
+	"hours.count": "该时段的活跃事件数（与 tokens 并列；用于活跃度热力，不含内容）。",
+	scope: "分析层级：global（默认，跨项目聚合）/ project（额外给 projects[]）/ session（额外给 sessions_detail[]）。",
+	projects: "每项目跨会话的派生信号桶（tokens/tool_calls/cache_hit_rate/categories/git_top/prompt_signals）；仅 --scope project。",
+	sessions_detail: "每会话的派生信号桶（含 session_id/duration_seconds 等）；仅 --scope session；不含 prompt 原文。",
+	duration: "活跃时长（相邻事件间隔 ≤5 分钟才计入），非墙钟跨度。"
+};
+
+//#endregion
+//#region src/pricing.ts
+const priceTable = [
+	{
+		prefix: "gpt-5.5",
+		p: {
+			input: 5,
+			cachedInput: .5,
+			output: 30
+		}
+	},
+	{
+		prefix: "gpt-5.4-mini",
+		p: {
+			input: .75,
+			cachedInput: .075,
+			output: 4.5
+		}
+	},
+	{
+		prefix: "gpt-5.4-nano",
+		p: {
+			input: .2,
+			cachedInput: .02,
+			output: 1.25
+		}
+	},
+	{
+		prefix: "gpt-5.4",
+		p: {
+			input: 2.5,
+			cachedInput: .25,
+			output: 15
+		}
+	},
+	{
+		prefix: "gpt-5.3-codex",
+		p: {
+			input: 1.75,
+			cachedInput: .175,
+			output: 14
+		}
+	},
+	{
+		prefix: "gpt-5.2-codex",
+		p: {
+			input: 1.75,
+			cachedInput: .175,
+			output: 14
+		}
+	},
+	{
+		prefix: "gpt-5.2",
+		p: {
+			input: 1.75,
+			cachedInput: .175,
+			output: 14
+		}
+	},
+	{
+		prefix: "gpt-5.1-codex-mini",
+		p: {
+			input: .25,
+			cachedInput: .025,
+			output: 2
+		}
+	},
+	{
+		prefix: "gpt-5.1",
+		p: {
+			input: 1.25,
+			cachedInput: .125,
+			output: 10
+		}
+	},
+	{
+		prefix: "gpt-5-mini",
+		p: {
+			input: .25,
+			cachedInput: .025,
+			output: 2
+		}
+	},
+	{
+		prefix: "gpt-5-nano",
+		p: {
+			input: .05,
+			cachedInput: .005,
+			output: .4
+		}
+	},
+	{
+		prefix: "gpt-5",
+		p: {
+			input: 1.25,
+			cachedInput: .125,
+			output: 10
+		}
+	},
+	{
+		prefix: "codex-mini",
+		p: {
+			input: 1.5,
+			cachedInput: .375,
+			output: 6
+		}
+	},
+	{
+		prefix: "claude-opus",
+		p: {
+			input: 5,
+			cachedInput: .5,
+			output: 25,
+			cacheCreation: 6.25
+		}
+	},
+	{
+		prefix: "claude-sonnet",
+		p: {
+			input: 3,
+			cachedInput: .3,
+			output: 15,
+			cacheCreation: 3.75
+		}
+	},
+	{
+		prefix: "claude-haiku",
+		p: {
+			input: 1,
+			cachedInput: .1,
+			output: 5,
+			cacheCreation: 1.25
+		}
+	}
+];
+function normalizeModel(model) {
+	let m = model.trim().toLowerCase();
+	if (m.startsWith("gpt5") && !m.startsWith("gpt-5")) m = "gpt-5" + m.slice(4);
+	if (m.startsWith("codex-mini")) return "codex-mini";
+	return m;
+}
+function disjointInputBuckets(model) {
+	return normalizeModel(model).startsWith("claude");
+}
+function lookupPrice(model) {
+	const m = normalizeModel(model);
+	let bestLen = -1;
+	let best;
+	for (const e of priceTable) if (m.startsWith(e.prefix) && e.prefix.length > bestLen) {
+		bestLen = e.prefix.length;
+		best = e.p;
+	}
+	return {
+		price: best ?? {
+			input: 0,
+			cachedInput: 0,
+			output: 0
+		},
+		found: bestLen >= 0
+	};
+}
+function estimateCost(d, model) {
+	const { price, found } = lookupPrice(model);
+	if (!found) return {
+		usd: 0,
+		priced: false
+	};
+	let usd;
+	if (price.cacheCreation !== void 0) usd = d.input * price.input / 1e6 + d.cached_input * price.cachedInput / 1e6 + d.cache_creation * price.cacheCreation / 1e6 + d.output * price.output / 1e6;
+	else {
+		const cached = Math.min(d.cached_input, d.input);
+		const nonCached = d.input - cached;
+		usd = nonCached * price.input / 1e6 + cached * price.cachedInput / 1e6 + d.output * price.output / 1e6;
+	}
+	return {
+		usd,
+		priced: true
+	};
+}
+
+//#endregion
+//#region src/text.ts
+const GIT_SUBCMDS = new Set([
+	"add",
+	"commit",
+	"push",
+	"pull",
+	"fetch",
+	"diff",
+	"status",
+	"log",
+	"checkout",
+	"branch",
+	"merge",
+	"rebase",
+	"stash",
+	"show",
+	"reset",
+	"clone",
+	"switch",
+	"restore",
+	"tag",
+	"cherry-pick",
+	"revert",
+	"rev-parse",
+	"remote",
+	"init",
+	"blame"
+]);
+function firstToken(cmd) {
+	if (typeof cmd !== "string") return "";
+	cmd = cmd.trim();
+	for (const part of cmd.split(/\s+/).filter(Boolean)) {
+		if (part.includes("=") && !/^[-/.]/.test(part)) {
+			const name = part.split("=", 1)[0];
+			if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) continue;
+		}
+		return part.split("/").pop();
+	}
+	return "";
+}
+function gitSubcommand(cmd) {
+	if (typeof cmd !== "string") return null;
+	const toks = cmd.trim().split(/\s+/).filter(Boolean);
+	let seenGit = false;
+	for (const t of toks) {
+		const base = t.split("/").pop();
+		if (!seenGit) {
+			if (base === "git") seenGit = true;
+			continue;
+		}
+		if (t.startsWith("-")) continue;
+		const sub = base.toLowerCase();
+		if (GIT_SUBCMDS.has(sub)) return sub;
+		return null;
+	}
+	return null;
+}
+function extOf(filePath) {
+	if (typeof filePath !== "string" || !filePath) return "";
+	const base = filePath.split("/").pop();
+	if (!base.includes(".")) return "";
+	return base.split(".").pop().toLowerCase();
+}
+function repoName(cwd) {
+	if (typeof cwd !== "string" || !cwd) return "(unknown)";
+	const name = cwd.replace(/\/+$/, "").split("/").pop();
+	return name || "(unknown)";
+}
+function comma(n) {
+	const neg = n < 0;
+	let s = String(Math.abs(Math.trunc(n)));
+	const parts = [];
+	while (s.length > 3) {
+		parts.unshift(s.slice(s.length - 3));
+		s = s.slice(0, s.length - 3);
+	}
+	parts.unshift(s);
+	const out = parts.join(",");
+	return neg ? "-" + out : out;
+}
+
+//#endregion
+//#region src/habits.ts
+function topCounts(counts, n) {
+	const cc = Object.entries(counts).map(([command, count]) => ({
+		command,
+		count
+	}));
+	cc.sort((a, b) => {
+		if (a.count !== b.count) return b.count - a.count;
+		return a.command < b.command ? -1 : a.command > b.command ? 1 : 0;
+	});
+	return cc.length > n ? cc.slice(0, n) : cc;
+}
+function buildGitHabits(gitCommands, branchCount, multiBranchRepos) {
+	const commandCount = Object.values(gitCommands).reduce((sum, n) => sum + n, 0);
+	const top = topCounts(gitCommands, 10);
+	const status = gitCommands.status ?? 0;
+	const diff = gitCommands.diff ?? 0;
+	const log = gitCommands.log ?? 0;
+	const show = gitCommands.show ?? 0;
+	const commit = gitCommands.commit ?? 0;
+	const push = gitCommands.push ?? 0;
+	const reviewSignals = [];
+	if (status > 0) reviewSignals.push(`经常检查工作区状态: git status ${status} 次`);
+	if (diff > 0) reviewSignals.push(`会查看差异: git diff ${diff} 次`);
+	if (log > 0 || show > 0) reviewSignals.push("会读取历史上下文");
+	const riskSignals = [];
+	if (commit === 0 && (diff > 0 || status > 0)) riskSignals.push("只看到 diff/status 等检查、没有 commit 提交；可能偏向让人类最后提交");
+	if (push > 0) riskSignals.push("观察到 push 命令；适合在 AGENTS.md 中写清推送前检查");
+	return {
+		command_count: commandCount,
+		top_subcommands: top.length > 0 ? top : void 0,
+		branch_count: branchCount,
+		multi_branch_repos: multiBranchRepos,
+		review_signals: reviewSignals.length > 0 ? reviewSignals : void 0,
+		risk_signals: riskSignals.length > 0 ? riskSignals : void 0
+	};
+}
+function buildProjectMgmt(repos) {
+	const reposWithTests = repos.filter((r) => r.hasTests === true).length;
+	const reposWithBuildSystem = repos.filter((r) => r.hasBuild === true).length;
+	const reposWithCI = repos.filter((r) => r.hasCI === true).length;
+	const signals = [];
+	if (repos.length > 0) {
+		if (reposWithTests === 0) signals.push("活跃项目中没有观察到测试命令");
+		else signals.push(`${reposWithTests}/${repos.length} 个活跃项目观察到测试命令`);
+		if (reposWithCI > 0) signals.push(`${reposWithCI} 个活跃项目检测到 GitHub Actions`);
+	}
+	return {
+		repos_with_tests: reposWithTests,
+		repos_with_build_system: reposWithBuildSystem,
+		repos_with_ci: reposWithCI,
+		signals: signals.length > 0 ? signals : void 0
+	};
+}
+
+//#endregion
+//#region src/language.ts
+const EXT_LANG = {
+	py: "Python",
+	go: "Go",
+	js: "JavaScript",
+	jsx: "JavaScript",
+	ts: "TypeScript",
+	tsx: "TypeScript",
+	rs: "Rust",
+	java: "Java",
+	kt: "Kotlin",
+	swift: "Swift",
+	c: "C",
+	h: "C/C++ Header",
+	cc: "C++",
+	cpp: "C++",
+	cxx: "C++",
+	hpp: "C++ Header",
+	rb: "Ruby",
+	php: "PHP",
+	cs: "C#",
+	sh: "Shell",
+	bash: "Shell",
+	zsh: "Shell",
+	fish: "Shell",
+	html: "HTML",
+	htm: "HTML",
+	css: "CSS",
+	scss: "CSS",
+	less: "CSS",
+	md: "Markdown",
+	json: "JSON",
+	yaml: "YAML",
+	yml: "YAML",
+	toml: "TOML",
+	xml: "XML",
+	sql: "SQL",
+	vue: "Vue",
+	svelte: "Svelte",
+	dart: "Dart",
+	scala: "Scala",
+	lua: "Lua",
+	r: "R",
+	ipynb: "Jupyter",
+	txt: "Text",
+	cfg: "Config",
+	ini: "Config",
+	env: "Config",
+	gradle: "Gradle",
+	proto: "Protobuf"
+};
+const AUX_LABELS = new Set([
+	"Markdown",
+	"Config",
+	"Text",
+	"JSON",
+	"YAML",
+	"TOML",
+	"XML"
+]);
+function dominantLanguage(fileTypes) {
+	const entries = fileTypes instanceof Map ? [...fileTypes.entries()] : Object.entries(fileTypes);
+	let best;
+	for (const [extRaw, count] of entries) {
+		const ext = extRaw.toLowerCase();
+		const lang = EXT_LANG[ext];
+		if (!lang || AUX_LABELS.has(lang)) continue;
+		if (!best || count > best.count || count === best.count && ext < best.ext) best = {
+			lang,
+			count,
+			ext
+		};
+	}
+	return best?.lang;
+}
+
+//#endregion
+//#region src/prompt-signals.ts
+const CONSTRAINT_WORDS_EN = [
+	"must",
+	"should",
+	"don't",
+	"do not",
+	"only",
+	"never",
+	"ensure",
+	"require",
+	"avoid",
+	"without",
+	"acceptance"
+];
+const CONSTRAINT_WORDS_ZH = [
+	"必须",
+	"应该",
+	"不要",
+	"不能",
+	"只",
+	"确保",
+	"需要",
+	"避免",
+	"禁止",
+	"验收",
+	"务必"
+];
+const CORRECTION_STARTS_EN = [
+	"actually",
+	"instead",
+	"wait",
+	"no,",
+	"no ",
+	"not ",
+	"sorry",
+	"oops",
+	"rather"
+];
+const CORRECTION_STARTS_ZH = [
+	"不对",
+	"重来",
+	"不是",
+	"错了",
+	"应该是",
+	"改成",
+	"其实",
+	"等等",
+	"算了"
+];
+const LIST_RE = /(^|\n)\s*([-*•]|\d+[.)])\s+/;
+const _FILE_EXT_GROUP = "(?:py|go|js|jsx|ts|tsx|rs|java|kt|swift|c|h|cc|cpp|cxx|hpp|rb|php|cs|sh|bash|zsh|html|htm|css|scss|less|md|json|yaml|yml|toml|xml|sql|vue|svelte|dart|scala|lua|ipynb|cfg|ini|env|gradle|proto|txt|lock|mod)";
+const FILE_REF_RE = new RegExp("@[\\w\\-]*[./][\\w./\\-]+|(?:[\\w\\-]+/)+[\\w\\-.]*\\." + _FILE_EXT_GROUP + "\\b|\\b[\\w\\-]+\\." + _FILE_EXT_GROUP + "\\b", "i");
+function newPromptAcc() {
+	return {
+		count: 0,
+		len_sum: 0,
+		structured: 0,
+		file_ref: 0,
+		constraint: 0,
+		correction: 0
+	};
+}
+function promptAccUpdate(acc, rawText) {
+	if (typeof rawText !== "string") return;
+	const text = rawText.trim();
+	if (!text) return;
+	acc.count += 1;
+	acc.len_sum += [...text].length;
+	const low = text.toLowerCase();
+	if (text.includes("```") || LIST_RE.test(text)) acc.structured += 1;
+	if (FILE_REF_RE.test(text)) acc.file_ref += 1;
+	if (CONSTRAINT_WORDS_EN.some((w) => low.includes(w)) || CONSTRAINT_WORDS_ZH.some((w) => text.includes(w))) acc.constraint += 1;
+	if (CORRECTION_STARTS_EN.some((w) => low.startsWith(w)) || CORRECTION_STARTS_ZH.some((w) => text.startsWith(w))) acc.correction += 1;
+}
+function promptFlags(text) {
+	const low = text.toLowerCase();
+	return {
+		len: [...text].length,
+		structured: text.includes("```") || LIST_RE.test(text),
+		file_ref: FILE_REF_RE.test(text),
+		constraint: CONSTRAINT_WORDS_EN.some((w) => low.includes(w)) || CONSTRAINT_WORDS_ZH.some((w) => text.includes(w)),
+		correction: CORRECTION_STARTS_EN.some((w) => low.startsWith(w)) || CORRECTION_STARTS_ZH.some((w) => text.startsWith(w))
+	};
+}
+function promptSignals(acc) {
+	const n = acc.count;
+	if (!n) return {
+		prompts: 0,
+		avg_len: 0,
+		structured_ratio: 0,
+		file_ref_ratio: 0,
+		constraint_ratio: 0,
+		correction_rate: 0
+	};
+	const r4 = (x) => Math.round(x * 1e4) / 1e4;
+	return {
+		prompts: n,
+		avg_len: Math.round(acc.len_sum / n * 10) / 10,
+		structured_ratio: r4(acc.structured / n),
+		file_ref_ratio: r4(acc.file_ref / n),
+		constraint_ratio: r4(acc.constraint / n),
+		correction_rate: r4(acc.correction / n)
+	};
+}
+
+//#endregion
+//#region src/aggregate.ts
+const IDLE_CAP_MS = 5 * 60 * 1e3;
+const REPOS_MAX = 50;
+const USAGE_MAX = 15;
+const MT_MODELS_MAX = 10;
+const MT_DAYS_MAX = 31;
+var Aggregator = class {
+	platform;
+	tokens = emptyTokens();
+	cost = 0;
+	freshInput = 0;
+	shellCalls = 0;
+	webSearches = 0;
+	fileChanges = 0;
+	totalCalls = 0;
+	shellCommands = new Map();
+	gitCommands = new Map();
+	sessionIds = new Set();
+	durationMs = 0;
+	prevActive = null;
+	byRepo = new Map();
+	byHour = new Array(24).fill(0);
+	byHourCount = new Array(24).fill(0);
+	categories = new Map();
+	toolByName = new Map();
+	langFiles = new Map();
+	bySource = new Map();
+	byLanguage = new Map();
+	byModelDay = new Map();
+	modelsSeen = new Set();
+	missingPrice = new Set();
+	promptAcc = newPromptAcc();
+	errToolResults = 0;
+	errToolErrors = 0;
+	errInterrupted = 0;
+	errApiErrors = 0;
+	errByTool = new Map();
+	errByCategory = new Map();
+	rwEdits = 0;
+	rwUserModified = 0;
+	rwLinesAdded = 0;
+	rwLinesRemoved = 0;
+	skillCounts = new Map();
+	versions = new Set();
+	permModes = new Map();
+	attachments = 0;
+	subagentMsgs = 0;
+	billingByTier = new Map();
+	billingUnclassified = 0;
+	billingSessionsWithPlan = 0;
+	billingSessionsUnclassified = 0;
+	cxLabels = new Map();
+	cxCompactions = 0;
+	cxAbortedTurns = 0;
+	cxContextWindow = new Map();
+	cxGitIdentity = false;
+	cxNonDefaultProvider = false;
+	clWebSearchReq = 0;
+	clWebFetchReq = 0;
+	scope;
+	groups = new Map();
+	curBucket = null;
+	constructor(platform, scope = "global") {
+		this.platform = platform;
+		this.scope = scope;
+	}
+	beginRecord(repo, session, ts) {
+		this.curBucket = null;
+		if (this.scope === "global") return;
+		let key;
+		if (this.scope === "session") {
+			if (!session) return;
+			key = session;
+		} else {
+			const r = (repo ?? "").trim();
+			if (!r || r === "(unknown)") return;
+			key = r;
+		}
+		let g = this.groups.get(key);
+		if (!g) {
+			g = {
+				key,
+				repo: this.scope === "session" ? "(unknown)" : key,
+				sessions: new Set(),
+				tokens: 0,
+				cacheRead: 0,
+				input: 0,
+				toolCalls: 0,
+				cat: new Map(),
+				git: new Map(),
+				prompt: newPromptAcc(),
+				first: null,
+				last: null
+			};
+			this.groups.set(key, g);
+		}
+		if (this.scope === "session" && repo && repo !== "(unknown)" && g.repo === "(unknown)") g.repo = repo;
+		if (this.scope === "project" && session) g.sessions.add(session);
+		if (ts && !Number.isNaN(ts.getTime())) {
+			const t = ts.getTime();
+			if (g.first === null || t < g.first) g.first = t;
+			if (g.last === null || t > g.last) g.last = t;
+		}
+		this.curBucket = g;
+	}
+	repoFor(repo) {
+		let name = (repo ?? "").trim();
+		if (!name) name = "(unknown)";
+		let r = this.byRepo.get(name);
+		if (!r) {
+			r = {
+				repo: name,
+				sessions: new Set(),
+				tokens: 0,
+				cost: 0,
+				branches: new Set(),
+				fileTypes: new Map(),
+				hasTests: false,
+				hasBuild: false,
+				hasCI: false
+			};
+			this.byRepo.set(name, r);
+		}
+		return r;
+	}
+	applyTokens(d, model, repo, session, ts, branch) {
+		this.tokens.input += d.input;
+		this.tokens.cached_input += d.cached_input;
+		this.tokens.output += d.output;
+		this.tokens.reasoning_output += d.reasoning_output;
+		this.tokens.cache_creation += d.cache_creation;
+		this.tokens.total += d.total;
+		const { usd, priced } = estimateCost(d, model);
+		this.cost += usd;
+		const nm = normalizeModel(model);
+		if (nm) {
+			this.modelsSeen.add(nm);
+			if (!priced && model.trim() !== "") this.missingPrice.add(nm);
+		}
+		this.freshInput += disjointInputBuckets(model) ? d.input : Math.max(0, d.input - Math.min(d.cached_input, d.input));
+		const r = this.repoFor(repo);
+		r.tokens += d.total;
+		r.cost += usd;
+		if (session) r.sessions.add(session);
+		if (branch) r.branches.add(branch);
+		if (nm) this.applyModelDay(nm, ts, d, usd);
+		this.byHour[ts.getHours()] += d.total;
+		this.byHourCount[ts.getHours()]++;
+		if (this.curBucket) {
+			this.curBucket.tokens += d.total;
+			this.curBucket.cacheRead += d.cached_input;
+			this.curBucket.input += d.input;
+		}
+	}
+	applyModelDay(model, ts, d, cost) {
+		const day = localYmd(ts);
+		let days = this.byModelDay.get(model);
+		if (!days) {
+			days = new Map();
+			this.byModelDay.set(model, days);
+		}
+		let md = days.get(day);
+		if (!md) {
+			md = {
+				tokens: 0,
+				cost: 0,
+				input: 0,
+				cached_input: 0,
+				output: 0,
+				reasoning_output: 0,
+				cache_creation: 0
+			};
+			days.set(day, md);
+		}
+		md.tokens += d.total;
+		md.cost += cost;
+		md.input += d.input;
+		md.cached_input += d.cached_input;
+		md.output += d.output;
+		md.reasoning_output += d.reasoning_output;
+		md.cache_creation += d.cache_creation;
+	}
+	applyTool(kind, command) {
+		this.totalCalls++;
+		this.categories.set(kind, (this.categories.get(kind) ?? 0) + 1);
+		if (kind === "shell") {
+			this.shellCalls++;
+			if (command) {
+				const ft = firstToken(command);
+				if (ft) this.shellCommands.set(ft, (this.shellCommands.get(ft) ?? 0) + 1);
+				const gs = gitSubcommand(command);
+				if (gs) this.gitCommands.set(gs, (this.gitCommands.get(gs) ?? 0) + 1);
+			}
+		} else if (kind === "web") this.webSearches++;
+		else if (kind === "file") this.fileChanges++;
+		if (this.curBucket) {
+			this.curBucket.toolCalls++;
+			this.curBucket.cat.set(kind, (this.curBucket.cat.get(kind) ?? 0) + 1);
+			if (kind === "shell" && command) {
+				const gs = gitSubcommand(command);
+				if (gs) this.curBucket.git.set(gs, (this.curBucket.git.get(gs) ?? 0) + 1);
+			}
+		}
+	}
+	applyToolName(name) {
+		if (name) this.toolByName.set(name, (this.toolByName.get(name) ?? 0) + 1);
+	}
+	applyLanguageFile(ext) {
+		if (!ext) return;
+		const lang = EXT_LANG[ext.toLowerCase()] ?? ext.toUpperCase();
+		this.langFiles.set(lang, (this.langFiles.get(lang) ?? 0) + 1);
+	}
+	applyFileChangeExt(repo, ext) {
+		if (!ext) return;
+		const r = this.repoFor(repo);
+		r.fileTypes.set(ext, (r.fileTypes.get(ext) ?? 0) + 1);
+	}
+	applyUsage(groups, name, tokens, session) {
+		let n = (name ?? "").trim();
+		if (!n) n = "(unknown)";
+		let g = groups.get(n);
+		if (!g) {
+			g = {
+				name: n,
+				tokens: 0,
+				sessions: new Set()
+			};
+			groups.set(n, g);
+		}
+		g.tokens += tokens.total;
+		if (session) g.sessions.add(session);
+	}
+	applyUsageSource(name, tokens, session) {
+		this.applyUsage(this.bySource, name, tokens, session);
+	}
+	applyLanguage(name, tokens, session) {
+		this.applyUsage(this.byLanguage, name, tokens, session);
+	}
+	applyRepoFacts(repo, facts) {
+		const r = this.repoFor(repo);
+		if (facts.hasTests) r.hasTests = true;
+		if (facts.hasBuild) r.hasBuild = true;
+		if (facts.hasCI) r.hasCI = true;
+	}
+	applyPrompt(text) {
+		promptAccUpdate(this.promptAcc, text);
+		if (this.curBucket) promptAccUpdate(this.curBucket.prompt, text);
+	}
+	applyToolResult(toolName, isError, category) {
+		this.errToolResults++;
+		if (isError) {
+			this.errToolErrors++;
+			const tn = toolName || "(unknown)";
+			this.errByTool.set(tn, (this.errByTool.get(tn) ?? 0) + 1);
+			if (category) this.errByCategory.set(category, (this.errByCategory.get(category) ?? 0) + 1);
+		}
+	}
+	markInterrupted() {
+		this.errInterrupted++;
+	}
+	applyApiError() {
+		this.errApiErrors++;
+	}
+	applyEdit(linesAdded, linesRemoved, userModified) {
+		this.rwEdits++;
+		if (userModified) this.rwUserModified++;
+		this.rwLinesAdded += linesAdded;
+		this.rwLinesRemoved += linesRemoved;
+	}
+	applySkill(name) {
+		if (name) this.skillCounts.set(name, (this.skillCounts.get(name) ?? 0) + 1);
+	}
+	applyVersion(v) {
+		if (v) this.versions.add(v);
+	}
+	applyPermissionMode(m) {
+		if (m) this.permModes.set(m, (this.permModes.get(m) ?? 0) + 1);
+	}
+	markAttachment() {
+		this.attachments++;
+	}
+	markSubagentMessage() {
+		this.subagentMsgs++;
+	}
+	applyBillingRollout(planType, tokens) {
+		if (tokens <= 0) return;
+		if (planType) {
+			this.billingByTier.set(planType, (this.billingByTier.get(planType) ?? 0) + tokens);
+			this.billingSessionsWithPlan++;
+		} else {
+			this.billingUnclassified += tokens;
+			this.billingSessionsUnclassified++;
+		}
+	}
+	applyCodexLabel(field, label) {
+		if (!field || !label) return;
+		let m = this.cxLabels.get(field);
+		if (!m) {
+			m = new Map();
+			this.cxLabels.set(field, m);
+		}
+		m.set(label, (m.get(label) ?? 0) + 1);
+	}
+	markCodexCompaction() {
+		this.cxCompactions++;
+	}
+	markCodexAbortedTurn() {
+		this.cxAbortedTurns++;
+	}
+	applyCodexContextWindow(n) {
+		if (n > 0) this.cxContextWindow.set(n, (this.cxContextWindow.get(n) ?? 0) + 1);
+	}
+	markCodexGitIdentity() {
+		this.cxGitIdentity = true;
+	}
+	markCodexNonDefaultProvider() {
+		this.cxNonDefaultProvider = true;
+	}
+	getCodexNonDefaultProvider() {
+		return this.cxNonDefaultProvider;
+	}
+	applyClaudeServerTool(webSearch, webFetch) {
+		this.clWebSearchReq += webSearch;
+		this.clWebFetchReq += webFetch;
+	}
+	touchSession(id) {
+		if (id) this.sessionIds.add(id);
+	}
+	markActive(ts) {
+		const t = ts.getTime();
+		if (this.prevActive !== null) {
+			const gap = t - this.prevActive;
+			if (gap > 0 && gap <= IDLE_CAP_MS) this.durationMs += gap;
+		}
+		this.prevActive = t;
+	}
+	resetActive() {
+		this.prevActive = null;
+	}
+	durationSeconds() {
+		return Math.floor(this.durationMs / 1e3);
+	}
+	assemble(window, source) {
+		const cached = this.tokens.cached_input;
+		const denom = cached + this.freshInput;
+		const cacheHitRate = denom > 0 ? cached / denom : 0;
+		const reasoningRatio = this.tokens.output > 0 ? this.tokens.reasoning_output / this.tokens.output : 0;
+		const repos = [];
+		const repoFacts = [];
+		const branchSet = new Set();
+		let multiBranchRepos = 0;
+		for (const r of this.byRepo.values()) {
+			const branches = [...r.branches].filter(Boolean).sort();
+			const rep = {
+				repo: r.repo,
+				sessions: r.sessions.size,
+				tokens: r.tokens,
+				estimated_cost_usd: r.cost
+			};
+			if (branches.length) rep.branches = branches;
+			const lang = dominantLanguage(r.fileTypes);
+			if (lang) rep.language = lang;
+			repos.push(rep);
+			repoFacts.push({
+				hasTests: r.hasTests,
+				hasBuild: r.hasBuild,
+				hasCI: r.hasCI
+			});
+			for (const b of r.branches) branchSet.add(r.repo + "@" + b);
+			if (r.branches.size > 1) multiBranchRepos++;
+		}
+		repos.sort((a, b) => b.tokens - a.tokens);
+		const hours = [];
+		for (let h = 0; h < 24; h++) if (this.byHour[h] > 0) hours.push({
+			hour: h,
+			tokens: this.byHour[h],
+			count: this.byHourCount[h]
+		});
+		const shellRecord = {};
+		for (const [k, v] of this.shellCommands) shellRecord[k] = v;
+		const gitRecord = {};
+		for (const [k, v] of this.gitCommands) gitRecord[k] = v;
+		const errToolRec = {};
+		for (const [k, v] of this.errByTool) errToolRec[k] = v;
+		const errCatRec = {};
+		for (const [k, v] of this.errByCategory) errCatRec[k] = v;
+		const errorSignals = {
+			tool_calls: this.errToolResults,
+			tool_errors: this.errToolErrors,
+			error_rate: this.errToolResults > 0 ? Math.round(this.errToolErrors / this.errToolResults * 1e4) / 1e4 : 0,
+			interrupted: this.errInterrupted,
+			api_errors: this.errApiErrors
+		};
+		if (this.errByTool.size) errorSignals.by_tool = topCounts(errToolRec, 8);
+		if (this.errByCategory.size) errorSignals.by_category = topCounts(errCatRec, 8);
+		const reworkSignals = {
+			edits: this.rwEdits,
+			user_modified: this.rwUserModified,
+			user_modified_rate: this.rwEdits > 0 ? Math.round(this.rwUserModified / this.rwEdits * 1e4) / 1e4 : 0,
+			lines_added: this.rwLinesAdded,
+			lines_removed: this.rwLinesRemoved
+		};
+		const skillRec = {};
+		for (const [k, v] of this.skillCounts) skillRec[k] = v;
+		const permRec = {};
+		for (const [k, v] of this.permModes) permRec[k] = v;
+		const report = {
+			generated_for: window.desc,
+			timezone: localTimezone(),
+			platform: this.platform,
+			source,
+			sessions: this.sessionIds.size,
+			duration_seconds: this.durationSeconds(),
+			duration: humanizeDuration(this.durationMs),
+			tokens: { ...this.tokens },
+			cache_hit_rate: cacheHitRate,
+			reasoning_ratio: reasoningRatio,
+			estimated_cost_usd: this.cost,
+			models: [...this.modelsSeen].sort(),
+			tools: {
+				shell_calls: this.shellCalls,
+				web_searches: this.webSearches,
+				file_changes: this.fileChanges,
+				total_calls: this.totalCalls,
+				top_commands: topCounts(shellRecord, 12)
+			},
+			repos: repos.slice(0, REPOS_MAX),
+			hours,
+			sources: usageReports(this.bySource).slice(0, USAGE_MAX),
+			languages: usageReports(this.byLanguage).slice(0, USAGE_MAX),
+			git_habits: buildGitHabits(gitRecord, branchSet.size, multiBranchRepos),
+			project_management: buildProjectMgmt(repoFacts),
+			prompt_signals: promptSignals(this.promptAcc),
+			error_signals: errorSignals,
+			rework_signals: reworkSignals,
+			rate_limits: null,
+			glossary: REPORT_GLOSSARY
+		};
+		if (this.toolByName.size) {
+			const byNameRec = {};
+			for (const [k, v] of this.toolByName) byNameRec[k] = v;
+			report.tools.by_name = topCounts(byNameRec, 15).map((c) => ({
+				name: c.command,
+				count: c.count
+			}));
+		}
+		if (this.categories.size) {
+			const cats = {};
+			for (const [k, v] of this.categories) cats[k] = v;
+			report.tools.categories = cats;
+		}
+		if (this.langFiles.size) report.file_languages = [...this.langFiles.entries()].sort((a, b) => b[1] !== a[1] ? b[1] - a[1] : a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).slice(0, USAGE_MAX).map(([name, files]) => ({
+			name,
+			files
+		}));
+		if (this.skillCounts.size) report.skills = topCounts(skillRec, 12);
+		if (this.attachments || this.subagentMsgs || this.versions.size || this.permModes.size) {
+			const env = {
+				attachments: this.attachments,
+				subagent_messages: this.subagentMsgs
+			};
+			if (this.versions.size) env.claude_versions = [...this.versions].sort();
+			if (this.permModes.size) env.permission_modes = topCounts(permRec, 8);
+			report.environment = env;
+		}
+		if (this.billingByTier.size || this.billingUnclassified || this.billingSessionsWithPlan || this.billingSessionsUnclassified) {
+			const byTier = {};
+			for (const [k, v] of this.billingByTier) byTier[k] = v;
+			const billing = {
+				by_plan_tier: byTier,
+				unclassified: this.billingUnclassified,
+				sessions_with_plan: this.billingSessionsWithPlan,
+				sessions_unclassified: this.billingSessionsUnclassified,
+				confidence: "spoofable-by-relay"
+			};
+			report.billing = billing;
+		}
+		if (this.cxLabels.size || this.cxCompactions || this.cxAbortedTurns || this.cxContextWindow.size || this.cxGitIdentity) {
+			const cs = {
+				compactions: this.cxCompactions,
+				aborted_turns: this.cxAbortedTurns,
+				git_repo_identity: this.cxGitIdentity
+			};
+			const asRec = (m) => {
+				if (!m || !m.size) return void 0;
+				const r = {};
+				for (const [k, v] of m) r[k] = v;
+				return r;
+			};
+			cs.effort = asRec(this.cxLabels.get("effort"));
+			cs.approval_policy = asRec(this.cxLabels.get("approval_policy"));
+			cs.sandbox = asRec(this.cxLabels.get("sandbox"));
+			cs.collaboration_mode = asRec(this.cxLabels.get("collaboration_mode"));
+			cs.personality = asRec(this.cxLabels.get("personality"));
+			cs.originators = asRec(this.cxLabels.get("originators"));
+			if (this.cxContextWindow.size) {
+				let best = 0;
+				let bestC = -1;
+				for (const [n, c] of this.cxContextWindow) if (c > bestC) {
+					bestC = c;
+					best = n;
+				}
+				cs.context_window = best;
+			}
+			report.codex_specific = cs;
+		}
+		if (this.clWebSearchReq || this.clWebFetchReq) {
+			const cl = {
+				web_search_requests: this.clWebSearchReq,
+				web_fetch_requests: this.clWebFetchReq
+			};
+			report.claude_specific = cl;
+		}
+		if (this.scope !== "global") {
+			report.scope = this.scope;
+			const toBucket = (g) => {
+				const denom$1 = g.cacheRead + g.input;
+				const cat = {};
+				for (const [k, v] of g.cat) cat[k] = v;
+				const gitRec = {};
+				for (const [k, v] of g.git) gitRec[k] = v;
+				return {
+					tokens: g.tokens,
+					tool_calls: g.toolCalls,
+					cache_hit_rate: denom$1 > 0 ? Math.round(g.cacheRead / denom$1 * 1e4) / 1e4 : 0,
+					categories: cat,
+					git_top: topCounts(gitRec, 6),
+					prompt_signals: promptSignals(g.prompt)
+				};
+			};
+			if (this.scope === "project") report.projects = [...this.groups.values()].map((g) => ({
+				repo: g.key,
+				sessions: g.sessions.size,
+				...toBucket(g)
+			})).sort((a, b) => b.tokens - a.tokens);
+			else report.sessions_detail = [...this.groups.values()].map((g) => ({
+				session_id: g.key,
+				repo: g.repo,
+				duration_seconds: g.first !== null && g.last !== null ? Math.floor((g.last - g.first) / 1e3) : 0,
+				...toBucket(g)
+			})).sort((a, b) => b.tokens - a.tokens);
+		} else report.scope = "global";
+		if (this.missingPrice.size) report.unpriced_models = [...this.missingPrice].sort();
+		if (this.byModelDay.size) {
+			report.models_timeline = buildModelsTimeline(this.byModelDay);
+			report.model_tokens = buildModelTokens(this.byModelDay, this.missingPrice);
+		}
+		return report;
+	}
+};
+function usageReports(groups) {
+	const out = [...groups.values()].map((g) => ({
+		name: g.name,
+		sessions: g.sessions.size,
+		tokens: g.tokens
+	}));
+	out.sort((a, b) => b.tokens !== a.tokens ? b.tokens - a.tokens : a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+	return out;
+}
+function buildModelsTimeline(byModelDay) {
+	const out = [];
+	for (const [model, days] of byModelDay) {
+		const dayKeys = [...days.keys()].sort();
+		let tokens = 0;
+		let cost = 0;
+		const dayCounts = [];
+		for (const d of dayKeys) {
+			const da = days.get(d);
+			tokens += da.tokens;
+			cost += da.cost;
+			dayCounts.push({
+				date: d,
+				tokens: da.tokens
+			});
+		}
+		out.push({
+			model,
+			first_day: dayKeys[0],
+			last_day: dayKeys[dayKeys.length - 1],
+			tokens,
+			estimated_cost_usd: cost,
+			days: dayCounts.slice(-MT_DAYS_MAX)
+		});
+	}
+	out.sort((a, b) => b.tokens !== a.tokens ? b.tokens - a.tokens : a.model < b.model ? -1 : a.model > b.model ? 1 : 0);
+	return out.slice(0, MT_MODELS_MAX);
+}
+function buildModelTokens(byModelDay, missingPrice) {
+	const out = [];
+	for (const [model, days] of byModelDay) {
+		const t = emptyTokens();
+		let cost = 0;
+		for (const md of days.values()) {
+			t.input += md.input;
+			t.cached_input += md.cached_input;
+			t.output += md.output;
+			t.reasoning_output += md.reasoning_output;
+			t.cache_creation += md.cache_creation;
+			t.total += md.tokens;
+			cost += md.cost;
+		}
+		out.push({
+			model,
+			tokens: t,
+			estimated_cost_usd: cost,
+			priced: !missingPrice.has(model)
+		});
+	}
+	out.sort((a, b) => b.tokens.total !== a.tokens.total ? b.tokens.total - a.tokens.total : a.model < b.model ? -1 : a.model > b.model ? 1 : 0);
+	return out.slice(0, MT_MODELS_MAX);
+}
+function humanizeDuration(ms) {
+	if (ms <= 0) return "0m";
+	const totalMin = Math.floor(ms / 6e4);
+	const h = Math.floor(totalMin / 60);
+	const m = totalMin % 60;
+	return h > 0 ? `${h}h${m}m` : `${m}m`;
+}
+function localTimezone() {
+	const tz = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+	const offsetMin = -new Date().getTimezoneOffset();
+	const sign = offsetMin >= 0 ? "+" : "-";
+	const abs = Math.abs(offsetMin);
+	const hours = Math.trunc(abs / 60);
+	const mins = abs % 60;
+	const off = mins ? `${hours}:${String(mins).padStart(2, "0")}` : `${hours}`;
+	return `${tz} (UTC${sign}${off})`;
+}
+
+//#endregion
+//#region src/errors.ts
+function classifyError(errorText) {
+	const t = typeof errorText === "string" ? errorText : "";
+	if (/not been read|read it first before/i.test(t)) return "not-read";
+	if (/permission denied|EACCES|not permitted|operation not permitted/i.test(t)) return "permission";
+	if (/ETIMEDOUT|timed out|deadline exceeded/i.test(t)) return "timeout";
+	if (/ECONNREFUSED|ENOTFOUND|EAI_AGAIN|getaddrinfo|fetch failed|network is unreachable/i.test(t)) return "network";
+	if (/\bFAIL\b|tests? failed|assertionerror|✗ /i.test(t)) return "test";
+	if (/fatal:|not a git repository|exit code 128/i.test(t)) return "git";
+	if (/npm (err|error)|cannot find module|\btsc\b|build failed|cargo |compil(e|ation)|\bgo: /i.test(t)) return "build";
+	return "other";
+}
+
+//#endregion
+//#region src/parsers/claude-code.ts
+function claudeProjectsDir() {
+	const cfg = process.env.CLAUDE_CONFIG_DIR;
+	if (cfg && cfg.trim()) return join(cfg.trim(), "projects");
+	return join(homedir(), ".claude", "projects");
+}
+function walkJsonl(dir) {
+	const out = [];
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return out;
+	}
+	for (const e of entries) {
+		const p = join(dir, e.name);
+		if (e.isDirectory()) out.push(...walkJsonl(p));
+		else if (e.isFile() && e.name.endsWith(".jsonl")) out.push(p);
+	}
+	return out.sort();
+}
+function num$1(x) {
+	return typeof x === "number" && isFinite(x) ? x : 0;
+}
+function userText(message) {
+	const content = message?.content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	for (const c of content) if (typeof c === "string") parts.push(c);
+	else if (c && c.type === "text" && typeof c.text === "string") parts.push(c.text);
+	return parts.join("\n");
+}
+function feedClaudeCode(agg, dir, window) {
+	const seen = new Set();
+	const maxUsageByKey = new Map();
+	const files = walkJsonl(dir);
+	const toolUseNames = new Map();
+	const sessionEntrypoint = new Map();
+	for (const file of files) {
+		let pre;
+		try {
+			pre = readFileSync(file, "utf8");
+		} catch {
+			continue;
+		}
+		for (const line of pre.split("\n")) {
+			const t = line.trim();
+			if (!t) continue;
+			let rec;
+			try {
+				rec = JSON.parse(t);
+			} catch {
+				continue;
+			}
+			const psid = typeof rec?.sessionId === "string" ? rec.sessionId : "";
+			const pep = typeof rec?.entrypoint === "string" ? rec.entrypoint.trim() : "";
+			if (psid && pep && !sessionEntrypoint.has(psid)) sessionEntrypoint.set(psid, pep);
+			if (rec?.type !== "assistant") continue;
+			const blocks = Array.isArray(rec.message?.content) ? rec.message.content : [];
+			for (const b of blocks) if (b && b.type === "tool_use" && typeof b.id === "string") toolUseNames.set(b.id, b.name);
+			const pmsgId = rec?.message?.id;
+			const pKey = typeof pmsgId === "string" && pmsgId !== "" ? `${pmsgId}:${rec?.requestId ?? ""}` : typeof rec?.uuid === "string" && rec.uuid !== "" ? rec.uuid : null;
+			if (pKey !== null) {
+				const u = rec.message?.usage ?? {};
+				const input = num$1(u.input_tokens);
+				const cachedInput = num$1(u.cache_read_input_tokens);
+				const output = num$1(u.output_tokens);
+				const cacheCreation = num$1(u.cache_creation_input_tokens);
+				const total = input + output + cachedInput + cacheCreation;
+				const prev = maxUsageByKey.get(pKey);
+				if (!prev || total > prev.total) maxUsageByKey.set(pKey, {
+					input,
+					cached_input: cachedInput,
+					output,
+					reasoning_output: 0,
+					cache_creation: cacheCreation,
+					total
+				});
+			}
+		}
+	}
+	for (const file of files) {
+		agg.resetActive();
+		let content;
+		try {
+			content = readFileSync(file, "utf8");
+		} catch {
+			continue;
+		}
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			let rec;
+			try {
+				rec = JSON.parse(trimmed);
+			} catch {
+				continue;
+			}
+			const tsRaw = rec?.timestamp;
+			if (typeof tsRaw !== "string") continue;
+			const ts = new Date(tsRaw);
+			if (Number.isNaN(ts.getTime())) continue;
+			if (!inLocalRange(ts, window)) continue;
+			const msgId = rec?.message?.id;
+			const dedupKey = typeof msgId === "string" && msgId !== "" ? `${msgId}:${rec?.requestId ?? ""}` : typeof rec?.uuid === "string" && rec.uuid !== "" ? rec.uuid : null;
+			if (dedupKey !== null) {
+				if (seen.has(dedupKey)) continue;
+				seen.add(dedupKey);
+			}
+			const sidechain = rec?.isSidechain === true;
+			const session = typeof rec.sessionId === "string" ? rec.sessionId : "";
+			const repo = repoName(typeof rec.cwd === "string" ? rec.cwd : "");
+			const branch = typeof rec.gitBranch === "string" ? rec.gitBranch : void 0;
+			if (rec.isApiErrorMessage === true && !sidechain) agg.applyApiError();
+			if (typeof rec.version === "string") agg.applyVersion(rec.version);
+			if (typeof rec.permissionMode === "string") agg.applyPermissionMode(rec.permissionMode);
+			if (typeof rec.attributionSkill === "string") agg.applySkill(rec.attributionSkill);
+			if (rec.type === "attachment") agg.markAttachment();
+			if (sidechain) agg.markSubagentMessage();
+			agg.beginRecord(repo, sidechain ? "" : session, ts);
+			if (rec.type === "user") {
+				if (!sidechain) {
+					agg.touchSession(session);
+					const text = userText(rec.message);
+					if (text) agg.applyPrompt(text);
+					const blocks = Array.isArray(rec.message?.content) ? rec.message.content : [];
+					for (const b of blocks) {
+						if (!b || b.type !== "tool_result") continue;
+						const toolName = (typeof b.tool_use_id === "string" ? toolUseNames.get(b.tool_use_id) : void 0) ?? "(unknown)";
+						const isError = b.is_error === true;
+						let category = null;
+						if (isError) {
+							const txt = typeof b.content === "string" ? b.content : Array.isArray(b.content) ? b.content.map((c) => c && typeof c.text === "string" ? c.text : "").join(" ") : "";
+							category = classifyError(txt);
+						}
+						agg.applyToolResult(toolName, isError, category);
+					}
+					const tur = rec.toolUseResult;
+					if (tur && typeof tur === "object") {
+						if (tur.interrupted === true) agg.markInterrupted();
+						if (Array.isArray(tur.structuredPatch)) {
+							let added = 0;
+							let removed = 0;
+							for (const h of tur.structuredPatch) if (h && Array.isArray(h.lines)) {
+								for (const l of h.lines) if (typeof l === "string") {
+									if (l.startsWith("+")) added++;
+									else if (l.startsWith("-")) removed++;
+								}
+							}
+							agg.applyEdit(added, removed, tur.userModified === true);
+						}
+					}
+				}
+			} else if (rec.type === "assistant") {
+				const msg = rec.message ?? {};
+				const best = dedupKey !== null ? maxUsageByKey.get(dedupKey) : void 0;
+				let tokens;
+				if (best) tokens = { ...best };
+				else {
+					const usage = msg.usage ?? {};
+					const input = num$1(usage.input_tokens);
+					const cachedInput = num$1(usage.cache_read_input_tokens);
+					const output = num$1(usage.output_tokens);
+					const cacheCreation = num$1(usage.cache_creation_input_tokens);
+					tokens = {
+						input,
+						cached_input: cachedInput,
+						output,
+						reasoning_output: 0,
+						cache_creation: cacheCreation,
+						total: input + output + cachedInput + cacheCreation
+					};
+				}
+				const model = typeof msg.model === "string" ? msg.model : "";
+				agg.applyTokens(tokens, model, repo, sidechain ? "" : session, ts, branch);
+				if (!sidechain) {
+					agg.touchSession(session);
+					agg.markActive(ts);
+					const ep = sessionEntrypoint.get(session);
+					if (ep) agg.applyUsageSource(ep, tokens, session);
+					const stu = (msg.usage ?? {}).server_tool_use;
+					if (stu && typeof stu === "object") agg.applyClaudeServerTool(num$1(stu.web_search_requests), num$1(stu.web_fetch_requests));
+					const blocks = Array.isArray(msg.content) ? msg.content : [];
+					for (const b of blocks) {
+						if (!b || b.type !== "tool_use") continue;
+						const name = typeof b.name === "string" ? b.name : "";
+						const inp = b.input ?? {};
+						agg.applyToolName(name);
+						if (name === "Bash") agg.applyTool("shell", typeof inp.command === "string" ? inp.command : void 0);
+						else if (name === "WebFetch" || name === "WebSearch") agg.applyTool("web");
+						else if (name === "Edit" || name === "Write" || name === "Read" || name === "NotebookEdit") {
+							agg.applyTool("file");
+							const ext = extOf(typeof inp.file_path === "string" ? inp.file_path : "");
+							agg.applyFileChangeExt(repo, ext);
+							agg.applyLanguageFile(ext);
+						} else if (name === "Glob" || name === "Grep" || name === "ToolSearch") agg.applyTool("search");
+						else if (name.startsWith("mcp__")) agg.applyTool("mcp");
+						else agg.applyTool("other");
+					}
+				}
+			}
+		}
+	}
+}
+
+//#endregion
+//#region src/parsers/codex.ts
+function codexOutcome(output) {
+	if (typeof output !== "string") return {
+		exitCode: null,
+		text: "",
+		interrupted: false
+	};
+	let parsed = null;
+	try {
+		parsed = JSON.parse(output);
+	} catch {}
+	if (parsed && typeof parsed === "object") {
+		const meta = parsed.metadata ?? {};
+		const ec = meta.exit_code ?? parsed.exit_code;
+		return {
+			exitCode: typeof ec === "number" ? ec : null,
+			text: typeof parsed.output === "string" ? parsed.output : output,
+			interrupted: meta.interrupted === true || parsed.interrupted === true
+		};
+	}
+	return {
+		exitCode: null,
+		text: output,
+		interrupted: false
+	};
+}
+function codexHome() {
+	const env = process.env.CODEX_HOME;
+	if (env && env.trim()) return env.trim();
+	return join(homedir(), ".codex");
+}
+function globRollouts(home) {
+	const root = join(home, "sessions");
+	const out = [];
+	const walk = (dir) => {
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of entries) {
+			const p = join(dir, e.name);
+			if (e.isDirectory()) walk(p);
+			else if (e.isFile() && e.name.startsWith("rollout-") && e.name.endsWith(".jsonl")) out.push(p);
+		}
+	};
+	walk(root);
+	return out.sort();
+}
+function num(x) {
+	return typeof x === "number" && isFinite(x) ? x : 0;
+}
+function fromCodex(o) {
+	return {
+		input: num(o?.input_tokens),
+		cached: num(o?.cached_input_tokens),
+		output: num(o?.output_tokens),
+		reasoning: num(o?.reasoning_output_tokens),
+		total: num(o?.total_tokens)
+	};
+}
+function satSub(a, b) {
+	const s = (x, y) => x < y ? 0 : x - y;
+	return {
+		input: s(a.input, b.input),
+		cached: s(a.cached, b.cached),
+		output: s(a.output, b.output),
+		reasoning: s(a.reasoning, b.reasoning),
+		total: s(a.total, b.total)
+	};
+}
+function addCodex(a, b) {
+	return {
+		input: a.input + b.input,
+		cached: a.cached + b.cached,
+		output: a.output + b.output,
+		reasoning: a.reasoning + b.reasoning,
+		total: a.total + b.total
+	};
+}
+function sourceKey(source) {
+	const s = (source ?? "").trim().toLowerCase();
+	if (s === "") return "(unknown)";
+	if (s.includes("vscode") || s.includes("ide")) return "plugin";
+	if (s.includes("codex-app") || s.includes("desktop") || s === "app") return "codex-app";
+	if (s.includes("cli") || s.includes("terminal")) return "cli";
+	return s;
+}
+function commandLine(args) {
+	if (!args) return "";
+	let a;
+	try {
+		a = JSON.parse(args);
+	} catch {
+		return "";
+	}
+	if (typeof a?.cmd === "string") return a.cmd.trim();
+	if (Array.isArray(a?.command)) return a.command.join(" ").trim();
+	return "";
+}
+function stripShellWrapper(fields) {
+	const wrappers = new Set([
+		"bash",
+		"sh",
+		"zsh",
+		"fish",
+		"-lc",
+		"-c",
+		"env"
+	]);
+	let f = fields;
+	while (f.length > 0) {
+		const head = f[0].replace(/^["'`]+|["'`]+$/g, "");
+		if (wrappers.has(head)) {
+			f = f.slice(1);
+			continue;
+		}
+		break;
+	}
+	return f;
+}
+function normalizedCommandLine(args) {
+	return stripShellWrapper(commandLine(args).split(/\s+/).filter(Boolean)).join(" ");
+}
+function isSubagentRollout(lines) {
+	for (const line of lines) {
+		const t = line.trim();
+		if (!t) continue;
+		let rec;
+		try {
+			rec = JSON.parse(t);
+		} catch {
+			continue;
+		}
+		if (rec?.type === "session_meta") {
+			const probe = { ...rec.payload ?? {} };
+			delete probe.cwd;
+			const s = JSON.stringify(probe);
+			return s.includes("subagent") || s.includes("thread_spawn");
+		}
+	}
+	return false;
+}
+function feedCodex(agg, home, window) {
+	const inWin = (d) => !Number.isNaN(d.getTime()) && inLocalRange(d, window);
+	for (const file of globRollouts(home)) {
+		let content;
+		try {
+			content = readFileSync(file, "utf8");
+		} catch {
+			continue;
+		}
+		const lines = content.split("\n");
+		const sidechain = isSubagentRollout(lines);
+		agg.resetActive();
+		let prevTotal = {
+			input: 0,
+			cached: 0,
+			output: 0,
+			reasoning: 0,
+			total: 0
+		};
+		let curModel = "";
+		let sessionId = "";
+		let repo = "(unknown)";
+		let source = "(unknown)";
+		let threadTouched = false;
+		let originator = "";
+		let gitIdentity = false;
+		let rolloutPlanType = null;
+		let billingTokens = 0;
+		const callNames = new Map();
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			let rec;
+			try {
+				rec = JSON.parse(trimmed);
+			} catch {
+				continue;
+			}
+			const tsRaw = rec?.timestamp;
+			const ts = typeof tsRaw === "string" ? new Date(tsRaw) : new Date(NaN);
+			const payload = rec?.payload ?? {};
+			switch (rec?.type) {
+				case "session_meta": {
+					if (!sessionId && typeof payload.id === "string") sessionId = payload.id;
+					if (source === "(unknown)" && typeof payload.source === "string") source = sourceKey(payload.source);
+					if (typeof payload.cwd === "string" && payload.cwd) repo = repoName(payload.cwd);
+					if (typeof payload.originator === "string" && payload.originator) originator = payload.originator;
+					const git = payload.git;
+					if (git && typeof git === "object" && (git.repository_url || git.commit_hash)) gitIdentity = true;
+					if (typeof payload.model_provider === "string" && payload.model_provider && payload.model_provider !== "openai") agg.markCodexNonDefaultProvider();
+					break;
+				}
+				case "compacted": {
+					if (!sidechain && inWin(ts)) agg.markCodexCompaction();
+					break;
+				}
+				case "turn_context": {
+					if (typeof payload.model === "string" && payload.model) curModel = payload.model;
+					if (!sidechain && inWin(ts)) {
+						if (typeof payload.effort === "string") agg.applyCodexLabel("effort", payload.effort);
+						if (typeof payload.approval_policy === "string") agg.applyCodexLabel("approval_policy", payload.approval_policy);
+						const sb = payload.sandbox_policy;
+						if (sb && typeof sb === "object") {
+							const mode = typeof sb.mode === "string" ? sb.mode : typeof sb.type === "string" ? sb.type : "";
+							if (mode) agg.applyCodexLabel("sandbox", mode);
+						}
+						const cm = payload.collaboration_mode;
+						const cmMode = cm && typeof cm === "object" && typeof cm.mode === "string" ? cm.mode : typeof cm === "string" ? cm : "";
+						if (cmMode) agg.applyCodexLabel("collaboration_mode", cmMode);
+						if (typeof payload.personality === "string") agg.applyCodexLabel("personality", payload.personality);
+					}
+					break;
+				}
+				case "event_msg": {
+					if (payload.type === "error" || payload.type === "stream_error") {
+						if (!sidechain && inWin(ts)) agg.applyApiError();
+						break;
+					}
+					if (payload.type === "context_compacted") {
+						if (!sidechain && inWin(ts)) agg.markCodexCompaction();
+						break;
+					}
+					if (payload.type === "turn_aborted") {
+						if (!sidechain && inWin(ts)) agg.markCodexAbortedTurn();
+						break;
+					}
+					if (payload.type !== "token_count") break;
+					const rl = payload.rate_limits;
+					if (rl && typeof rl === "object" && rolloutPlanType === null && typeof rl.plan_type === "string" && rl.plan_type) rolloutPlanType = rl.plan_type;
+					const info = payload.info;
+					if (!info) break;
+					let delta;
+					if (info.last_token_usage) {
+						delta = fromCodex(info.last_token_usage);
+						prevTotal = info.total_token_usage ? fromCodex(info.total_token_usage) : addCodex(prevTotal, delta);
+					} else if (info.total_token_usage) {
+						delta = satSub(fromCodex(info.total_token_usage), prevTotal);
+						prevTotal = fromCodex(info.total_token_usage);
+					} else break;
+					if (delta.cached > delta.input) delta.cached = delta.input;
+					if (delta.total <= 0) delta.total = delta.input + delta.output;
+					if (delta.input <= 0 && delta.cached <= 0 && delta.output <= 0 && delta.reasoning <= 0) break;
+					if (Number.isNaN(ts.getTime()) || !inLocalRange(ts, window)) break;
+					const tokens = {
+						input: delta.input,
+						cached_input: delta.cached,
+						output: delta.output,
+						reasoning_output: delta.reasoning,
+						cache_creation: 0,
+						total: delta.total
+					};
+					agg.beginRecord(repo, sidechain ? "" : sessionId, ts);
+					agg.applyTokens(tokens, curModel, repo, sidechain ? "" : sessionId, ts);
+					billingTokens += delta.total;
+					if (!sidechain && typeof info.model_context_window === "number") agg.applyCodexContextWindow(info.model_context_window);
+					if (sidechain) agg.markSubagentMessage();
+					else {
+						threadTouched = true;
+						agg.markActive(ts);
+					}
+					break;
+				}
+				case "response_item": {
+					if (sidechain) break;
+					if (Number.isNaN(ts.getTime()) || !inLocalRange(ts, window)) break;
+					agg.beginRecord(repo, sessionId, ts);
+					const t = payload.type;
+					if (t === "function_call") {
+						const name = payload.name;
+						if (typeof payload.call_id === "string") callNames.set(payload.call_id, name);
+						if (name === "exec_command" || name === "local_shell_call" || name === "shell") agg.applyTool("shell", normalizedCommandLine(typeof payload.arguments === "string" ? payload.arguments : ""));
+						else agg.applyTool("other");
+					} else if (t === "function_call_output" || t === "local_shell_call_output") {
+						const { exitCode, text, interrupted } = codexOutcome(payload.output);
+						const name = (typeof payload.call_id === "string" ? callNames.get(payload.call_id) : void 0) ?? "shell";
+						const isError = exitCode !== null && exitCode !== 0;
+						agg.applyToolResult(name, isError, isError ? classifyError(text) : null);
+						if (interrupted) agg.markInterrupted();
+					} else if (t === "local_shell_call") agg.applyTool("shell");
+					else if (t === "web_search_call") agg.applyTool("web");
+					else if (t === "custom_tool_call" || t === "image_generation_call") agg.applyTool("other");
+					break;
+				}
+			}
+		}
+		agg.applyBillingRollout(rolloutPlanType, billingTokens);
+		if (threadTouched) {
+			agg.touchSession(sessionId);
+			if (originator) agg.applyCodexLabel("originators", originator);
+			if (gitIdentity) agg.markCodexGitIdentity();
+		}
+	}
+}
+
+//#endregion
+//#region src/endpoint.ts
+const OFFICIAL_HOSTS = new Set([
+	"api.anthropic.com",
+	"api.openai.com",
+	"chatgpt.com"
+]);
+function readText(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return null;
+	}
+}
+function readJson(path) {
+	const t = readText(path);
+	if (t == null) return null;
+	try {
+		return JSON.parse(t);
+	} catch {
+		return null;
+	}
+}
+function hostOf(url) {
+	if (typeof url !== "string" || !url.trim()) return "";
+	let u = url.trim();
+	if (!/^[a-z]+:\/\//i.test(u)) u = "https://" + u;
+	try {
+		return new URL(u).hostname.toLowerCase();
+	} catch {
+		return "";
+	}
+}
+function classifyHost(host) {
+	if (!host) return { endpoint: "unknown" };
+	if (OFFICIAL_HOSTS.has(host)) return {
+		endpoint: "official",
+		officialHost: host
+	};
+	return { endpoint: "custom" };
+}
+function tomlActiveProvider(toml) {
+	for (const raw of toml.split("\n")) {
+		const line = raw.trim();
+		if (line.startsWith("[")) break;
+		const m = line.match(/^model_provider\s*=\s*["']([^"']+)["']/);
+		if (m) return m[1];
+	}
+	return null;
+}
+function tomlProviderBaseUrl(toml, name) {
+	const lines = toml.split("\n");
+	const esc = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const header = new RegExp(`^\\[model_providers\\.(?:"?${esc}"?)\\]\\s*$`);
+	let inSection = false;
+	for (const raw of lines) {
+		const line = raw.trim();
+		if (line.startsWith("[")) {
+			inSection = header.test(line);
+			continue;
+		}
+		if (inSection) {
+			const m = line.match(/^base_url\s*=\s*["']([^"']+)["']/);
+			if (m) return m[1];
+		}
+	}
+	return null;
+}
+function detectCodexEndpoint(home, nonDefaultProviderInJsonl) {
+	const basis = [];
+	let authMode;
+	const auth = readJson(join(home, "auth.json"));
+	if (auth && typeof auth === "object") {
+		if (typeof auth.auth_mode === "string") authMode = auth.auth_mode === "chatgpt" ? "chatgpt" : auth.auth_mode === "apikey" ? "apikey" : "other";
+		else if (auth.OPENAI_API_KEY) authMode = "apikey";
+		if (authMode) basis.push(`auth_mode:${authMode}`);
+	}
+	let endpoint = "unknown";
+	let officialHost;
+	const toml = readText(join(home, "config.toml"));
+	if (toml != null) {
+		const active = tomlActiveProvider(toml);
+		if (!active || active === "openai") {
+			endpoint = "official";
+			officialHost = "chatgpt.com";
+			basis.push("config:provider=openai");
+		} else {
+			const baseUrl = tomlProviderBaseUrl(toml, active);
+			const host = baseUrl ? hostOf(baseUrl) : "";
+			const c = classifyHost(host);
+			endpoint = c.endpoint === "unknown" ? "custom" : c.endpoint;
+			officialHost = c.officialHost;
+			basis.push(endpoint === "official" ? `base_url:official(${officialHost})` : "config:provider=custom");
+		}
+	} else {
+		endpoint = "official";
+		officialHost = "chatgpt.com";
+		basis.push("config:default");
+	}
+	if (nonDefaultProviderInJsonl) basis.push("jsonl:non-default-provider");
+	let billingMode = "unknown";
+	let confidence = "low";
+	if (endpoint === "custom") {
+		billingMode = "api_or_relay";
+		confidence = "high";
+	} else if (endpoint === "official") if (authMode === "chatgpt") {
+		billingMode = "subscription";
+		confidence = nonDefaultProviderInJsonl ? "medium" : "high";
+	} else if (authMode === "apikey") {
+		billingMode = "api_or_relay";
+		confidence = "high";
+	} else {
+		billingMode = "unknown";
+		confidence = "low";
+	}
+	const out = {
+		platform: "codex",
+		endpoint,
+		relay_suspected: endpoint === "custom",
+		non_default_provider: nonDefaultProviderInJsonl,
+		billing_mode: billingMode,
+		confidence,
+		basis
+	};
+	if (officialHost) out.official_host = officialHost;
+	if (authMode) out.auth_mode = authMode;
+	return out;
+}
+function detectClaudeEndpoint(home) {
+	const basis = [];
+	const envOf = (file) => {
+		const j = readJson(join(home, file));
+		const e = j && typeof j === "object" ? j.env : null;
+		return e && typeof e === "object" ? e : {};
+	};
+	const env = {
+		...envOf("settings.json"),
+		...envOf("settings.local.json")
+	};
+	const baseUrl = typeof env.ANTHROPIC_BASE_URL === "string" ? env.ANTHROPIC_BASE_URL : "";
+	const hasAuthToken = !!env.ANTHROPIC_AUTH_TOKEN;
+	const hasApiKey = !!env.ANTHROPIC_API_KEY;
+	let endpoint;
+	let officialHost;
+	if (baseUrl) {
+		const c = classifyHost(hostOf(baseUrl));
+		endpoint = c.endpoint === "unknown" ? "custom" : c.endpoint;
+		officialHost = c.officialHost;
+		basis.push(endpoint === "official" ? `base_url:official(${officialHost})` : "settings:ANTHROPIC_BASE_URL=custom");
+	} else {
+		endpoint = "official";
+		officialHost = "api.anthropic.com";
+		basis.push("settings:default");
+	}
+	let subscriptionType;
+	const creds = readJson(join(home, ".credentials.json"));
+	const oauth = creds && typeof creds === "object" ? creds.claudeAiOauth : null;
+	if (oauth && typeof oauth === "object" && typeof oauth.subscriptionType === "string") subscriptionType = oauth.subscriptionType;
+	let authMode;
+	if (hasAuthToken) authMode = "auth-token";
+	else if (hasApiKey) authMode = "api-key";
+	else if (oauth) authMode = "oauth-subscription";
+	if (authMode) basis.push(`auth_mode:${authMode}`);
+	if (subscriptionType) basis.push(`subscription:${subscriptionType}`);
+	let billingMode = "unknown";
+	let confidence = "low";
+	if (endpoint === "custom") {
+		billingMode = "api_or_relay";
+		confidence = "high";
+	} else if (authMode === "oauth-subscription") {
+		billingMode = "subscription";
+		confidence = "high";
+	} else if (authMode === "api-key" || authMode === "auth-token") {
+		billingMode = "api_or_relay";
+		confidence = "medium";
+	} else {
+		billingMode = "unknown";
+		confidence = "low";
+	}
+	const out = {
+		platform: "claude-code",
+		endpoint,
+		relay_suspected: endpoint === "custom",
+		billing_mode: billingMode,
+		confidence,
+		basis
+	};
+	if (officialHost) out.official_host = officialHost;
+	if (authMode) out.auth_mode = authMode;
+	if (subscriptionType) out.subscription_type = subscriptionType;
+	return out;
+}
+
+//#endregion
+//#region src/index.ts
+const VERSION = "0.1.0";
+function buildReport(opts) {
+	const { platform, window } = opts;
+	const scope = opts.scope ?? "global";
+	const claudeDir = opts.claudeDir ?? claudeProjectsDir();
+	const cxHome = opts.codexHome ?? codexHome();
+	const wantClaude = platform === "claude-code" || platform === "all";
+	const wantCodex = platform === "codex" || platform === "all";
+	const agg = new Aggregator(platform, scope);
+	if (wantClaude) feedClaudeCode(agg, claudeDir, window);
+	if (wantCodex) feedCodex(agg, cxHome, window);
+	const report = agg.assemble(window, "glob");
+	const endpoints = [];
+	if (wantCodex) endpoints.push(detectCodexEndpoint(cxHome, agg.getCodexNonDefaultProvider()));
+	if (wantClaude) endpoints.push(detectClaudeEndpoint(dirname(claudeDir)));
+	if (endpoints.length) report.endpoints = endpoints;
+	return report;
+}
+
+//#endregion
+export { VERSION, buildReport, claudeProjectsDir, codexHome, comma, inLocalRange, promptFlags, repoName, resolveWindow };