@alint-js/cli 0.5.0 → 0.7.0

package/dist/{cli-ChymU1Wr.mjs → cli-BsBgbtds.mjs}

@@ -1,24 +1,30 @@
 import process from "node:process";
 import { inspect } from "node:util";
 import { cac } from "cac";
-import { appendFile, mkdir, opendir, readFile, readdir, rm, stat } from "node:fs/promises";
-import { addProviderModels, getGlobalSetupConfigPath, getProjectSetupConfigPath, getStatsDir, installStaticPlugins, isAcpModel, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, normalizeSetupConfig, pruneProviderModels, removeProviderModels, replaceSetupProvider, setProviderEndpoint, setProviderHeader, unsetProviderHeader, writeSetupConfig } from "@alint-js/config";
-import { AlintRunCancelledError, AlintRunError, benchmarkModels, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, resolveConfigForDirectory, resolveConfigForFile, runAlint } from "@alint-js/core";
+import { appendFile, chmod, mkdir, opendir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { addProviderModels, getGlobalSetupConfigPath, getProjectSetupConfigPath, getStatsDir, installStaticPlugins, isAcpModel, loadAlintConfig, loadAlintConfigWithMetadata, loadSetupConfig, mergeSetupConfigs, normalizeSetupConfig, pruneProviderModels, removeProviderModels, replaceSetupProvider, setProviderEndpoint, setProviderHeader, setStopGateConfig, unsetProviderHeader, writeSetupConfig } from "@alint-js/config";
+import { AlintCachePersistenceError, AlintRunCancelledError, AlintRunError, benchmarkModels, defaultStopGateConfig, hasDiscoveryFilePatterns, matchesDiscoveryFile, maximumStopGateTimeoutMs, normalizeConfig, normalizeRunnerCacheConfig, resolveConfigForDirectory, resolveConfigForFile, resolveStopGateConfig, runAlint, stableHash } from "@alint-js/core";
 import { isAbsolute, join, relative, resolve } from "pathe";
-import { errorMessageFrom } from "@moeru/std/error";
+import { errorMessageFrom } from "@moeru/std";
+import { errorMessageFrom as errorMessageFrom$1 } from "@moeru/std/error";
 import { getBorderCharacters, table } from "table";
 import { createColors } from "tinyrainbow";
 import { createCommandModel, startGateway } from "@alint-js/model-adapter-acp";
 import cliSpinners from "cli-spinners";
 import fastStringWidth from "fast-string-width";
-import { relative as relative$1 } from "node:path";
-import fastStringTruncatedWidth from "fast-string-truncated-width";
-import { formatDuration, intervalToDuration } from "date-fns";
+import { parsePatch } from "diff";
+import { x } from "tinyexec";
+import { Buffer } from "node:buffer";
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join as join$1, relative as relative$1 } from "node:path";
+import { isNodeErrorCode } from "@alint-js/utils/node";
 import Gitignore from "gitignore-fs";
 import { Minimatch, minimatch } from "minimatch";
-import { errorMessageFrom as errorMessageFrom$1 } from "@moeru/std";
+import fastStringTruncatedWidth from "fast-string-truncated-width";
+import { formatDuration, intervalToDuration } from "date-fns";
 //#region package.json
-var version = "0.5.0";
+var version = "0.7.0";
 //#endregion
 //#region src/cli/output.ts
 function escapeLineValue(value) {
@@ -263,6 +269,115 @@ async function runConfigInspectCommand(path, configPath, io) {
 	return 0;
 }
 //#endregion
+//#region src/cli/commands/config/integrations/stop-gate.ts
+const set$1 = defineCommand({
+	async action(context, options) {
+		try {
+			let target;
+			if (options.target === void 0) target = void 0;
+			else if (options.target === "all" || options.target === "dirty-files") target = options.target;
+			else throw new Error("Stop Gate target must be \"all\" or \"dirty-files\".");
+			let timeoutMs;
+			if (options.timeoutMs !== void 0) {
+				timeoutMs = Number(options.timeoutMs);
+				if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > maximumStopGateTimeoutMs) throw new Error(`Stop Gate timeout must be an integer from 1 to ${maximumStopGateTimeoutMs}.`);
+			}
+			const result = await setStopGateConfig({
+				configFile: options.config,
+				cwd: context.io.cwd,
+				target,
+				timeoutMs
+			});
+			context.io.stdout.write(`config: ${result.configFile}\n`);
+			writeResolvedConfig((chunk) => context.io.stdout.write(chunk), result.config);
+			return 0;
+		} catch (error) {
+			context.io.stderr.write(`${errorMessageFrom(error) ?? "Failed to write Stop Gate config."}\n`);
+			return 2;
+		}
+	},
+	description: "Set Stop Gate config overrides in TOML",
+	exactArguments: true,
+	name: "set",
+	options: [{
+		description: "Lint target mode",
+		flags: "--target <target>"
+	}, {
+		description: "Overall Stop Gate timeout in milliseconds",
+		flags: "--timeout-ms <ms>"
+	}]
+});
+const enable = defineCommand({
+	action: (context) => setActivation(context, true),
+	description: "Enable Stop Gate for this repository",
+	exactArguments: true,
+	name: "enable"
+});
+const disable = defineCommand({
+	action: (context) => setActivation(context, false),
+	description: "Disable Stop Gate for this repository",
+	exactArguments: true,
+	name: "disable"
+});
+const stopGate$1 = defineCommand({
+	children: [
+		defineCommand({
+			async action(context, options) {
+				try {
+					const loaded = await loadAlintConfigWithMetadata(context.io.cwd, options.config);
+					const resolved = resolveStopGateConfig(loaded.config, context.io.cwd);
+					context.io.stdout.write(`config: ${loaded.configFile ?? "<not found>"}\n`);
+					writeResolvedConfig((chunk) => context.io.stdout.write(chunk), resolved);
+					return 0;
+				} catch (error) {
+					context.io.stderr.write(`${errorMessageFrom(error) ?? "Failed to read Stop Gate config."}\n`);
+					return 2;
+				}
+			},
+			description: "Show resolved Stop Gate config",
+			exactArguments: true,
+			name: "show"
+		}),
+		set$1,
+		enable,
+		disable
+	],
+	description: "Manage Stop Gate integration config",
+	examples: [
+		"alint config integrations stop-gate show",
+		"alint config integrations stop-gate enable",
+		"alint config integrations stop-gate disable",
+		"alint config integrations stop-gate set --target all --timeout-ms 1800000"
+	],
+	name: "stop-gate"
+});
+async function setActivation(context, enabled) {
+	try {
+		const result = await setStopGateConfig({
+			cwd: context.io.cwd,
+			enabled
+		});
+		context.io.stdout.write(`config: ${result.configFile}\n`);
+		writeResolvedConfig((chunk) => context.io.stdout.write(chunk), result.config);
+		return 0;
+	} catch (error) {
+		context.io.stderr.write(`${errorMessageFrom(error) ?? "Failed to write Stop Gate activation."}\n`);
+		return 2;
+	}
+}
+function writeResolvedConfig(write, config) {
+	write(`enabled: ${config.enabled}${config.enabled === defaultStopGateConfig.enabled ? " (default)" : ""}\n`);
+	write(`target: ${config.target}${config.target === defaultStopGateConfig.target ? " (default)" : ""}\n`);
+	write(`timeoutMs: ${config.timeoutMs}${config.timeoutMs === defaultStopGateConfig.timeoutMs ? " (default)" : ""}\n`);
+}
+//#endregion
+//#region src/cli/commands/config/integrations/integrations.ts
+const integrations$1 = defineCommand({
+	children: [stopGate$1],
+	description: "Manage external integration configuration",
+	name: "integrations"
+});
+//#endregion
 //#region src/cli/reporters/progress/bar.ts
 const minBarWidth = 4;
 const maxBarWidth = 16;
@@ -986,7 +1101,7 @@ async function runListModelsCommand(context, options) {
 	try {
 		providerConcurrency = resolveProviderBenchmarkConcurrency(config, concurrencyOverrides);
 	} catch (error) {
-		context.io.stderr.write(`${errorMessageFrom(error) ?? "Invalid benchmark concurrency override."}\n`);
+		context.io.stderr.write(`${errorMessageFrom$1(error) ?? "Invalid benchmark concurrency override."}\n`);
 		return 2;
 	}
 	const runtime = await startModelAdapters(config, context.io);
@@ -1030,7 +1145,7 @@ const probe$1 = defineCommand({
 			context.io.stdout.write(`${models.join("\n")}${models.length > 0 ? "\n" : ""}`);
 			return 0;
 		} catch (error) {
-			context.io.stderr.write(`failed to probe models: ${errorMessageFrom(error) ?? String(error)}\n`);
+			context.io.stderr.write(`failed to probe models: ${errorMessageFrom$1(error) ?? String(error)}\n`);
 			return 2;
 		}
 	},
@@ -1167,7 +1282,7 @@ function applyPlans(config, plans) {
 	return plans.reduce((nextConfig, plan) => pruneProviderModels(nextConfig, plan.provider.id, plan.remoteModelIds), config);
 }
 function classifyProbeFailure(error) {
-	const message = errorMessageFrom(error);
+	const message = errorMessageFrom$1(error);
 	const httpStatus = message?.match(/^GET .+ returned ([1-5]\d\d)\.$/u)?.[1];
 	if (httpStatus !== void 0) return `provider returned HTTP ${httpStatus}`;
 	if (error instanceof TypeError && message === "Expected OpenAI-compatible models response with data array.") return "provider returned an invalid models response";
@@ -1377,7 +1492,7 @@ const probe = defineCommand({
 			context.io.stdout.write(`endpoint: ${options.endpoint}\nmodels: ${models.length}\n`);
 			return 0;
 		} catch (error) {
-			context.io.stderr.write(`failed to probe provider: ${errorMessageFrom(error) ?? String(error)}\n`);
+			context.io.stderr.write(`failed to probe provider: ${errorMessageFrom$1(error) ?? String(error)}\n`);
 			return 2;
 		}
 	},
@@ -1795,7 +1910,7 @@ function createProviderEditorPrompts(prompts) {
 }
 function formatProbeModelsFailure(endpoint, error) {
 	const hint = endpoint.startsWith("https://localhost:11434") ? " Ollama usually uses http://localhost:11434/v1." : "";
-	return `Could not probe models: ${errorMessageFrom(error)}.${hint}`;
+	return `Could not probe models: ${errorMessageFrom$1(error)}.${hint}`;
 }
 function isBackInput(value) {
 	return value.trim() === "..";
@@ -2177,7 +2292,7 @@ async function runNonInteractiveUpdate(context, options, providerEndpoint, exist
 	try {
 		parsedHeaders = parseHeaderList(toArray$1(options.providerHeader));
 	} catch (error) {
-		context.io.stderr.write(`${errorMessageFrom(error) ?? "Invalid provider header."}\n`);
+		context.io.stderr.write(`${errorMessageFrom$1(error) ?? "Invalid provider header."}\n`);
 		return 2;
 	}
 	const draft = {
@@ -2189,7 +2304,7 @@ async function runNonInteractiveUpdate(context, options, providerEndpoint, exist
 	try {
 		remoteModelIds = await probeModels(endpoint, draft.headers);
 	} catch (error) {
-		context.io.stderr.write(`failed to probe provider: ${errorMessageFrom(error) ?? "Unknown error."}\n`);
+		context.io.stderr.write(`failed to probe provider: ${errorMessageFrom$1(error) ?? "Unknown error."}\n`);
 		return 2;
 	}
 	const replaced = replaceSetupProvider(config, draft);
@@ -2222,7 +2337,7 @@ async function runUpdateProviderCommand(context, options) {
 		providerId = scalarOption(options.provider, "--provider");
 		providerEndpoint = scalarOption(options.providerEndpoint, "--provider-endpoint");
 	} catch (error) {
-		context.io.stderr.write(`${errorMessageFrom(error) ?? "Invalid provider update option."}\n`);
+		context.io.stderr.write(`${errorMessageFrom$1(error) ?? "Invalid provider update option."}\n`);
 		return 2;
 	}
 	if (providerId === void 0) {
@@ -2270,6 +2385,7 @@ function toArray$1(value) {
 const config = defineCommand({
 	children: [
 		inspect$2,
+		integrations$1,
 		models,
 		defineCommand({
 			children: [
@@ -2332,1441 +2448,1927 @@ const config = defineCommand({
 	name: "config"
 });
 //#endregion
-//#region src/cli/reporters/json.ts
-function formatJson(result) {
-	return `${JSON.stringify(result, null, 2)}\n`;
+//#region src/cli/git.ts
+const gitTimeoutMs = 6e4;
+const gitlinkMode = "160000";
+/**
+* Collects staged, unstaged, and untracked changes relative to HEAD.
+* Deleted files and Git-controlled submodule worktrees stay outside the lint boundary.
+*/
+async function findDirtyChanges(cwd) {
+	const [tracked, untracked, patch, stagedEntries] = await Promise.all([
+		runGit(cwd, [
+			"diff",
+			"--name-only",
+			"-z",
+			"--diff-filter=ACMRTUXB",
+			"--find-renames",
+			"--ignore-submodules=none",
+			"HEAD",
+			"--"
+		]),
+		runGit(cwd, [
+			"ls-files",
+			"--others",
+			"--exclude-standard",
+			"-z"
+		]),
+		runGit(cwd, [
+			"diff",
+			"--no-color",
+			"--no-ext-diff",
+			"--unified=0",
+			"--diff-filter=ACMRTUXB",
+			"--find-renames",
+			"--ignore-submodules=none",
+			"--submodule=short",
+			"HEAD",
+			"--"
+		]),
+		runGit(cwd, [
+			"ls-files",
+			"--stage",
+			"-z"
+		])
+	]);
+	const gitlinks = parseGitlinks(stagedEntries);
+	const trackedFiles = withoutGitlinks(parseNullSeparatedPaths(tracked), gitlinks);
+	const untrackedFiles = withoutGitlinks(parseNullSeparatedPaths(untracked), gitlinks);
+	const files = [.../* @__PURE__ */ new Set([...trackedFiles, ...untrackedFiles])].sort();
+	const changedLines = changedLinesFromPatch(patch, gitlinks);
+	await Promise.all(untrackedFiles.map(async (file) => {
+		const content = await readFile(resolve(cwd, file), "utf8");
+		const lineCount = content.length === 0 ? 0 : content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+		if (lineCount > 0) changedLines.set(file, [{
+			endLine: lineCount,
+			startLine: 1
+		}]);
+	}));
+	return {
+		changedLines,
+		files
+	};
 }
-//#endregion
-//#region src/cli/reporters/stylish.ts
-const colors$3 = createColors({ force: true });
-function formatStylish(input, options = {}) {
-	const diagnostics = Array.isArray(input) ? input : input.diagnostics;
-	const result = Array.isArray(input) ? void 0 : input;
-	const style = createStyle(options.color === true);
-	if (diagnostics.length === 0) return result?.execution?.cached ? `${formatSummary(diagnostics, result, style)}\n` : "";
-	const diagnosticsByFile = /* @__PURE__ */ new Map();
-	for (const diagnostic of diagnostics) {
-		const fileDiagnostics = diagnosticsByFile.get(diagnostic.filePath);
-		if (fileDiagnostics) {
-			fileDiagnostics.push(diagnostic);
-			continue;
+async function findGitRoot(cwd) {
+	const root = (await runGit(cwd, ["rev-parse", "--show-toplevel"])).trim();
+	if (root.length === 0) throw new Error("Git did not return a repository root.");
+	return root;
+}
+function changedLinesFromPatch(patch, gitlinks) {
+	const changedLines = /* @__PURE__ */ new Map();
+	for (const file of parsePatch(patch)) {
+		const path = file.newFileName === void 0 || file.newFileName === "/dev/null" ? void 0 : file.newFileName.startsWith("b/") ? file.newFileName.slice(2) : file.newFileName;
+		if (path === void 0 || isWithinGitlink(path, gitlinks)) continue;
+		const lines = [];
+		for (const hunk of file.hunks) {
+			let newLine = hunk.newStart;
+			for (const line of hunk.lines) if (line.startsWith("+")) {
+				lines.push(newLine);
+				newLine += 1;
+			} else if (!line.startsWith("-") && !line.startsWith("\\")) newLine += 1;
 		}
-		diagnosticsByFile.set(diagnostic.filePath, [diagnostic]);
+		const ranges = lineRanges(lines);
+		if (ranges.length > 0) changedLines.set(path, ranges);
 	}
-	const lines = [];
-	for (const [filePath, fileDiagnostics] of diagnosticsByFile) {
-		lines.push(style.file(filePath));
-		for (const diagnostic of fileDiagnostics) {
-			const line = diagnostic.loc?.start.line ?? 0;
-			const column = diagnostic.loc?.start.column ?? 0;
-			const severity = diagnostic.severity === "warn" ? style.warning("warning") : style.error("error");
-			lines.push(`  ${style.location(`${line}:${column}`)}  ${severity}  ${diagnostic.message}  ${style.ruleId(diagnostic.ruleId)}`);
+	return changedLines;
+}
+function isWithinGitlink(path, gitlinks) {
+	for (const gitlink of gitlinks) if (path === gitlink || path.startsWith(`${gitlink}/`)) return true;
+	return false;
+}
+function lineRanges(lines) {
+	const ranges = [];
+	for (const line of lines) {
+		const previous = ranges.at(-1);
+		if (previous && line === previous.endLine + 1) previous.endLine = line;
+		else ranges.push({
+			endLine: line,
+			startLine: line
+		});
+	}
+	return ranges;
+}
+function parseGitlinks(output) {
+	const gitlinks = /* @__PURE__ */ new Set();
+	for (const entry of parseNullSeparatedPaths(output)) {
+		const separator = entry.indexOf("	");
+		if (separator === -1 || !entry.startsWith(`${gitlinkMode} `)) continue;
+		gitlinks.add(entry.slice(separator + 1));
+	}
+	return gitlinks;
+}
+function parseNullSeparatedPaths(output) {
+	return output.split("\0").filter((path) => path.length > 0);
+}
+async function runGit(cwd, args) {
+	return (await x("git", args, {
+		nodeOptions: { cwd },
+		nodePath: false,
+		throwOnError: true,
+		timeout: gitTimeoutMs
+	})).stdout;
+}
+function withoutGitlinks(paths, gitlinks) {
+	return paths.filter((path) => !isWithinGitlink(path, gitlinks));
+}
+//#endregion
+//#region src/cli/commands/integrations/stop-gate/envelope.ts
+function writeEnvelope(write, envelope) {
+	write(`${JSON.stringify(envelope)}\n`);
+}
+//#endregion
+//#region src/cli/commands/integrations/stop-gate/findings.ts
+function fingerprintDiagnostics(diagnostics) {
+	const diagnosticHashes = diagnostics.map((diagnostic) => stableHash({
+		evidence: diagnostic.evidence,
+		filePath: diagnostic.filePath,
+		loc: diagnostic.loc,
+		message: diagnostic.message,
+		ruleId: diagnostic.ruleId,
+		severity: diagnostic.severity
+	})).sort();
+	return stableHash({
+		diagnosticHashes,
+		schemaVersion: 1
+	});
+}
+//#endregion
+//#region src/cli/commands/integrations/stop-gate/report.ts
+const reportFileName = "report.json";
+const reportLimitBytes = 104857600;
+const stopGateTempRoot = join$1(tmpdir(), "alint-stop-gate");
+var StopGateReportTooLargeError = class extends Error {
+	constructor() {
+		super("Stop Gate report exceeds the 100 MB limit.");
+		this.name = "StopGateReportTooLargeError";
+	}
+};
+async function removeStopGateReport(sessionId) {
+	await rm(getReportPath(sessionId), { force: true });
+}
+async function writeStopGateReport(sessionId, report) {
+	const content = `${JSON.stringify(report, null, 2)}\n`;
+	if (Buffer.byteLength(content) > reportLimitBytes) throw new StopGateReportTooLargeError();
+	const sessionDirectory = getSessionDirectory(sessionId);
+	const reportPath = getReportPath(sessionId);
+	const tempPath = join$1(sessionDirectory, `report-${randomUUID()}.tmp`);
+	await mkdir(sessionDirectory, { recursive: true });
+	await writeFile(tempPath, content, {
+		encoding: "utf8",
+		mode: 420
+	});
+	await chmod(tempPath, 420);
+	await rename(tempPath, reportPath);
+	await enforceReportBudget(reportPath);
+	return reportPath;
+}
+async function enforceReportBudget(currentReportPath) {
+	let entries;
+	try {
+		entries = await readdir(stopGateTempRoot, { withFileTypes: true });
+	} catch (error) {
+		if (isNodeErrorCode(error, "ENOENT")) return;
+		throw error;
+	}
+	const reports = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const path = join$1(stopGateTempRoot, entry.name, reportFileName);
+		try {
+			const stats = await stat(path);
+			reports.push({
+				mtimeMs: stats.mtimeMs,
+				path,
+				size: stats.size
+			});
+		} catch (error) {
+			if (!isNodeErrorCode(error, "ENOENT")) throw error;
 		}
-		lines.push("");
 	}
-	lines.push("", formatSummary(diagnostics, result, style));
-	return `${lines.join("\n")}\n`;
+	let total = reports.reduce((sum, report) => sum + report.size, 0);
+	for (const report of reports.sort((left, right) => left.mtimeMs - right.mtimeMs)) {
+		if (total <= reportLimitBytes) break;
+		if (report.path === currentReportPath) continue;
+		await rm(report.path, { force: true });
+		total -= report.size;
+	}
 }
-function countCachedDiagnostics(diagnostics, severity) {
-	return diagnostics.filter((diagnostic) => diagnostic.severity === severity && diagnostic.cached === true).length;
+function getReportPath(sessionId) {
+	return join$1(getSessionDirectory(sessionId), reportFileName);
 }
-function countDiagnostics$1(diagnostics, severity) {
-	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
+function getSessionDirectory(sessionId) {
+	if (sessionId === "." || sessionId === ".." || !/^[\w.-]+$/u.test(sessionId)) throw new Error("Invalid Stop hook session id.");
+	return join$1(stopGateTempRoot, sessionId);
 }
-function createStyle(color) {
-	if (!color) return {
-		error: identity,
-		file: identity,
-		location: identity,
-		ruleId: identity,
-		summaryToken: identity,
-		warning: identity
+//#endregion
+//#region src/cli/commands/lint/discovery.ts
+const minimatchOptions = { dot: true };
+const directoryBufferSize = 256;
+var NoFilesFoundError = class extends Error {
+	globInputPaths;
+	pattern;
+	constructor(pattern, options) {
+		super(`No files matching "${pattern}" were found${options.globInputPaths ? "" : " (glob input is disabled)"}.`);
+		this.name = "NoFilesFoundError";
+		this.globInputPaths = options.globInputPaths;
+		this.pattern = pattern;
+	}
+};
+async function findDirtyLintTargets(config, cwd) {
+	const changes = await findDirtyChanges(cwd);
+	if (changes.files.length === 0) return {
+		changedLines: changes.changedLines,
+		directories: [],
+		files: []
 	};
 	return {
-		error: colors$3.red,
-		file: colors$3.underline,
-		location: colors$3.dim,
-		ruleId: colors$3.dim,
-		summaryToken: colors$3.cyan,
-		warning: colors$3.yellow
+		...await findLintTargets({
+			config,
+			cwd,
+			errorOnUnmatchedPattern: false,
+			globInputPaths: false,
+			inputs: changes.files
+		}),
+		changedLines: changes.changedLines
 	};
 }
-function formatDiagnosticCount(total, cached, label) {
-	return `${total} ${label}${cached > 0 ? ` (${cached} cached)` : ""}`;
+async function findLintTargets(options) {
+	const { config, cwd, errorOnUnmatchedPattern = true, globInputPaths = true, inputs } = options;
+	const gitignore = shouldFilterGitignoredFiles(config) ? new Gitignore() : void 0;
+	const targets = await resolveInputFiles({
+		config,
+		cwd,
+		errorOnUnmatchedPattern,
+		gitignore,
+		globInputPaths,
+		inputs: inputs.length > 0 ? inputs : ["."]
+	});
+	if (!gitignore || targets.files.length === 0) return targets;
+	const lintFiles = [];
+	for (const file of targets.files) {
+		if (await gitignore.ignores(resolve(cwd, file))) continue;
+		lintFiles.push(file);
+	}
+	return {
+		directories: targets.directories,
+		files: lintFiles
+	};
 }
-function formatExecutionSummary(execution) {
-	if (!execution || execution.cached === 0) return;
-	return `${execution.cached}/${execution.planned} cached`;
+function collectGlobalIgnorePatterns(config) {
+	return normalizeConfig(config).flatMap((item) => isGlobalIgnoreItem(item) ? [...item.ignores] : []);
 }
-function formatSummary(diagnostics, result, style) {
-	const warnCount = countDiagnostics$1(diagnostics, "warn");
-	const errorCount = countDiagnostics$1(diagnostics, "error");
-	const cachedWarnCount = countCachedDiagnostics(diagnostics, "warn");
-	const cachedErrorCount = countCachedDiagnostics(diagnostics, "error");
-	const tokens = result === void 0 ? void 0 : formatTokenSummary(result);
-	const problemSummary = [style.warning(formatDiagnosticCount(warnCount, cachedWarnCount, "warn")), style.error(formatDiagnosticCount(errorCount, cachedErrorCount, "error"))].join(" / ");
-	if (tokens === void 0) return problemSummary;
-	const execution = formatExecutionSummary(result?.execution);
-	return [
-		problemSummary,
-		style.summaryToken(tokens),
-		execution
-	].filter((segment) => segment !== void 0).join(" | ");
+function getGlobParent(input) {
+	const segments = input.replaceAll("\\", "/").split("/");
+	const parentSegments = [];
+	for (const segment of segments) {
+		if (isGlobPattern(segment)) break;
+		parentSegments.push(segment);
+	}
+	const parent = parentSegments.join("/");
+	return parent === "" ? "." : parent;
 }
-function formatTokenSummary(result) {
-	const liveTokens = result.usage.totalTokens.toLocaleString("en-US");
-	const cachedTokens = result.usage.cached?.totalTokens ?? 0;
-	return `${liveTokens} tokens${cachedTokens > 0 ? ` (${cachedTokens.toLocaleString("en-US")} cached)` : ""}`;
+function isGlobalIgnoreItem(item) {
+	const keys = Object.keys(item).filter((key) => item[key] !== void 0);
+	return item.ignores !== void 0 && keys.every((key) => key === "ignores" || key === "name");
 }
-function identity(value) {
-	return value;
+function isGlobPattern(input) {
+	return new Minimatch(input, minimatchOptions).hasMagic();
 }
-//#endregion
-//#region src/cli/reporters/index.ts
-function formatDiagnostics(format, result, options = {}) {
-	if (format === "json") return formatJson(result);
-	if (format === "stylish") return formatStylish(result, { color: options.color });
-	throw new Error(`Unknown reporter "${format}".`);
+function matchesGlob(filePath, pattern) {
+	return minimatch(filePath, pattern.replaceAll("\\", "/"), minimatchOptions);
 }
-//#endregion
-//#region src/cli/reporters/progress/plain.ts
-function createPlainProgressReporter(options) {
-	const writeLine = (line) => options.write(`${line}\n`);
-	return {
-		onJobRetry: () => {},
-		onJobStart: (payload) => {
-			const target = payload.job.target.name ? `${payload.job.target.kind} ${payload.job.target.name}` : payload.job.target.kind;
-			writeLine(`scan ${payload.job.inputPath} > ${target} > ${payload.job.ruleId}`);
-		},
-		onPrepareEnd: ({ filesTotal }) => writeLine(`alint prepared: ${filesTotal} files`),
-		onPrepareStart: () => writeLine("alint preparing"),
-		onRunEnd: (payload) => {
-			const warnCount = countDiagnostics(payload.diagnostics, "warn");
-			const errorCount = countDiagnostics(payload.diagnostics, "error");
-			const state = payload.execution.failed > 0 ? "failed" : "finished";
-			const { cached, cancelled, completed, failed, skipped } = payload.execution;
-			writeLine(`alint ${state}: ${warnCount} warn, ${errorCount} error, ${payload.usage.totalTokens} tokens, ${completed} completed, ${cached} cached, ${failed} failed, ${cancelled} cancelled, ${skipped} skipped`);
-		}
-	};
+function matchesIgnoredDirectory(relativePath, patterns) {
+	return patterns.some((pattern) => minimatch(relativePath, pattern, minimatchOptions) || minimatch(`${relativePath}/`, pattern, minimatchOptions) || minimatch(`${relativePath}/__alint__`, pattern, minimatchOptions));
 }
-function countDiagnostics(diagnostics, severity) {
-	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
+function normalizeGlobPattern(cwd, pattern) {
+	return isAbsolute(pattern) ? normalizeRelativePath(cwd, pattern) : pattern.replaceAll("\\", "/");
 }
-//#endregion
-//#region src/cli/reporters/progress/summary.ts
-const colors$2 = createColors({ force: true });
-const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function createSummaryProgressReporter(options) {
-	const now = Date.now;
-	const state = createInitialState();
-	return {
-		getRows: () => createRows(state, options, now()),
-		onDiagnostic: ({ diagnostic, progress }) => {
-			updateProgress(state, progress);
-			if (diagnostic.severity === "warn") state.warnCount += 1;
-			else state.errorCount += 1;
-		},
-		onExecuteEnd: ({ progress }) => {
-			updateProgress(state, progress);
-		},
-		onExecuteStart: ({ progress, startedAt }) => {
-			updateProgress(state, progress);
-			state.runStartedAt = startedAt ?? state.runStartedAt ?? now();
-		},
-		onFileReady: ({ progress }) => updateProgress(state, progress),
-		onJobEnd: (payload) => {
-			updateProgress(state, payload.progress);
-			const current = state.activeJobs.get(payload.job.id);
-			const group = state.ruleGroups.get(payload.job.ruleId);
-			if (!group) throw new Error(`Cannot finish unqueued progress job "${payload.job.id}".`);
-			group[payload.state] += 1;
-			if (payload.endedAt !== void 0 && current?.startedAt !== void 0 && payload.state !== "cached") group.terminalDurationMs += Math.max(payload.endedAt - current.startedAt, 0);
-			if (payload.state === "cached") {
-				const cachedTokens = state.jobTokens.get(payload.job.id) ?? 0;
-				state.totalTokens = Math.max(state.totalTokens - cachedTokens, 0);
-				state.cachedTokens += cachedTokens;
+function normalizeRelativePath(cwd, filePath) {
+	return relative(cwd, filePath).replaceAll("\\", "/");
+}
+async function resolveInputFiles(options) {
+	const hasFilePatterns = hasDiscoveryFilePatterns(options.config);
+	const ignoredPatterns = collectGlobalIgnorePatterns(options.config);
+	const candidates = [];
+	const directories = [];
+	for (const input of options.inputs) {
+		const path = resolve(options.cwd, input);
+		const stats = await statPath(path);
+		if (stats?.isFile()) {
+			candidates.push(input);
+			continue;
+		}
+		if (stats?.isDirectory()) {
+			if (await shouldPruneDirectory(path, {
+				cwd: options.cwd,
+				gitignore: options.gitignore,
+				ignoredPatterns
+			})) continue;
+			directories.push(input);
+			if (!hasFilePatterns) continue;
+			const directoryFiles = [];
+			for await (const file of walkFiles(path, {
+				cwd: options.cwd,
+				gitignore: options.gitignore,
+				ignoredPatterns
+			})) {
+				const relativePath = normalizeRelativePath(options.cwd, file);
+				if (hasFilePatterns && matchesDiscoveryFile(relativePath, options.config, { cwd: options.cwd })) directoryFiles.push(relativePath);
 			}
-			state.activeJobs.delete(payload.job.id);
-			state.jobTokens.delete(payload.job.id);
-		},
-		onJobQueued: ({ job, progress }) => {
-			updateProgress(state, progress);
-			const group = state.ruleGroups.get(job.ruleId) ?? createRuleGroup(job);
-			group.planned += 1;
-			state.ruleGroups.set(job.ruleId, group);
-			state.activeJobs.set(job.id, {
-				job,
-				state: "queued"
+			for (const file of directoryFiles.sort()) candidates.push(file);
+			continue;
+		}
+		if (options.globInputPaths && isGlobPattern(input)) {
+			const matches = await searchGlob({
+				config: options.config,
+				cwd: options.cwd,
+				gitignore: options.gitignore,
+				hasFilePatterns,
+				ignoredPatterns,
+				pattern: input
 			});
-		},
-		onJobRetry: (payload) => {
-			updateProgress(state, payload.progress);
-			const current = state.activeJobs.get(payload.job.id);
-			state.activeJobs.set(payload.job.id, {
-				job: payload.job,
-				retry: {
-					attempt: payload.attempt,
-					maxAttempts: payload.maxAttempts,
-					startedAt: payload.startedAt
-				},
-				startedAt: current?.startedAt ?? payload.startedAt ?? now(),
-				state: current?.state ?? "running"
+			if (matches.length === 0 && options.errorOnUnmatchedPattern) throw new NoFilesFoundError(input, { globInputPaths: options.globInputPaths });
+			for (const match of matches) candidates.push(match);
+			continue;
+		}
+		if (options.errorOnUnmatchedPattern) throw new NoFilesFoundError(input, { globInputPaths: options.globInputPaths });
+	}
+	return {
+		directories: [...new Set(directories)],
+		files: [...new Set(candidates)]
+	};
+}
+async function searchGlob(options) {
+	const root = resolve(options.cwd, getGlobParent(options.pattern));
+	const rootStats = await statPath(root);
+	const pattern = normalizeGlobPattern(options.cwd, options.pattern);
+	if (!rootStats?.isDirectory()) return [];
+	const candidates = [];
+	for await (const file of walkFiles(root, {
+		cwd: options.cwd,
+		gitignore: options.gitignore,
+		ignoredPatterns: options.ignoredPatterns
+	})) {
+		const relativePath = normalizeRelativePath(options.cwd, file);
+		if (matchesGlob(relativePath, pattern) && shouldIncludeGlobCandidate(relativePath, options.config, {
+			cwd: options.cwd,
+			hasFilePatterns: options.hasFilePatterns
+		})) candidates.push(relativePath);
+	}
+	return candidates.sort();
+}
+function shouldFilterGitignoredFiles(config) {
+	return normalizeConfig(config).some((item) => item.ignore?.gitignore === true);
+}
+function shouldIncludeGlobCandidate(filePath, config, options) {
+	if (options.hasFilePatterns) return matchesDiscoveryFile(filePath, config, { cwd: options.cwd });
+	return !resolveConfigForFile(filePath, config, { cwd: options.cwd }).ignored;
+}
+async function shouldPruneDirectory(path, options) {
+	if (matchesIgnoredDirectory(normalizeRelativePath(options.cwd, path), options.ignoredPatterns)) return true;
+	return await options.gitignore?.ignores(`${path}/`) === true;
+}
+async function statPath(path) {
+	try {
+		return await stat(path);
+	} catch (error) {
+		if (isNodeErrorCode(error, "ENOENT") || isNodeErrorCode(error, "ENOTDIR")) return;
+		throw error;
+	}
+}
+/**
+* Streams directory entries so unmatched trees never accumulate into recursive child arrays.
+* The consumer owns result ordering because filesystem iteration order is not stable.
+*/
+async function* walkFiles(root, options) {
+	const pendingDirectories = [root];
+	while (pendingDirectories.length > 0) {
+		const currentDirectory = pendingDirectories.pop();
+		if (currentDirectory === void 0) continue;
+		const childDirectories = [];
+		const directory = await opendir(currentDirectory, { bufferSize: directoryBufferSize });
+		for await (const entry of directory) {
+			const path = resolve(currentDirectory, entry.name);
+			if (entry.isDirectory()) {
+				if (!await shouldPruneDirectory(path, options)) childDirectories.push(path);
+				continue;
+			}
+			if (entry.isFile()) yield path;
+		}
+		for (const path of childDirectories.reverse()) pendingDirectories.push(path);
+	}
+}
+//#endregion
+//#region src/cli/runtime/runner.ts
+/**
+* Merges the setup config runner with the project config runner. No CLI flag is applied.
+*
+* `runner.cache` selects the cache file. The lint command and the language server must merge it
+* the same way, or the editor reads a different file and reports nothing.
+*/
+function mergeRunnerConfigs(setupRunner, configRunner) {
+	const runner = {
+		...setupRunner ?? {},
+		...configRunner ?? {},
+		cache: mergeCacheConfig(setupRunner?.cache, configRunner?.cache),
+		ruleConcurrency: configRunner?.ruleConcurrency ?? setupRunner?.ruleConcurrency,
+		stats: mergeStatsConfig(setupRunner?.stats, configRunner?.stats),
+		timeoutMs: configRunner?.timeoutMs ?? setupRunner?.timeoutMs
+	};
+	return Object.values(runner).some((value) => value !== void 0) ? runner : void 0;
+}
+/** The last `runner` block in the flattened config takes precedence, key by key. */
+function resolveConfigRunner(config) {
+	return normalizeConfig(config).reduce((merged, item) => item.runner ? {
+		...merged,
+		...item.runner
+	} : merged, void 0);
+}
+function mergeCacheConfig(setupCache, configCache) {
+	if (configCache === void 0) return setupCache;
+	if (typeof configCache === "boolean") return configCache;
+	if (typeof setupCache === "object") return {
+		...setupCache,
+		...configCache
+	};
+	return configCache;
+}
+function mergeStatsConfig(setupStats, configStats) {
+	if (configStats === void 0) return setupStats;
+	if (typeof configStats === "boolean") return configStats;
+	if (typeof setupStats === "object") return {
+		...setupStats,
+		...configStats
+	};
+	return configStats;
+}
+//#endregion
+//#region src/cli/runtime/session.ts
+/**
+* Loads config, setup config, and model adapters once, then runs any number of times.
+*
+* The lint command and the language server both use this function. A second implementation would
+* resolve config or cwd differently, and the editor would then read a different cache file.
+*/
+async function createRunSession(io, options = {}) {
+	const [{ defaultModel, setupConfig: fileSetupConfig }, config] = await Promise.all([loadRunSetupConfig(io), options.config ?? loadAlintConfig(io.cwd, options.configPath)]);
+	const runtime = await (options.startModelAdapters ?? startModelAdapters)(fileSetupConfig, io);
+	const { setupConfig } = runtime;
+	let shutdown;
+	const runner = mergeRunnerConfigs(setupConfig.runner, resolveConfigRunner(config));
+	return {
+		cache: normalizeRunnerCacheConfig(runner?.cache, io.cwd),
+		config,
+		cwd: io.cwd,
+		defaultModel,
+		run: async (runOptions) => {
+			const targets = runOptions.targets ?? await findLintTargets({
+				config,
+				cwd: io.cwd,
+				errorOnUnmatchedPattern: true,
+				globInputPaths: true,
+				inputs: runOptions.inputs ?? []
 			});
-		},
-		onJobStart: (payload) => {
-			updateProgress(state, payload.progress);
-			state.activeJobs.set(payload.job.id, {
-				job: payload.job,
-				startedAt: payload.startedAt ?? now(),
-				state: "running"
+			return runAlint({
+				cacheOnly: runOptions.cacheOnly,
+				config,
+				cwd: io.cwd,
+				defaultModel,
+				directories: targets.directories,
+				files: targets.files,
+				modelOverride: runOptions.modelOverride,
+				outputLanguage: runOptions.outputLanguage,
+				progress: runOptions.progress,
+				projectTargets: runOptions.projectTargets,
+				runner: runOptions.runner,
+				setupConfig,
+				signal: runOptions.signal
 			});
 		},
-		onPlanningEnd: ({ progress }) => updateProgress(state, progress),
-		onPrepareStart: ({ startedAt }) => {
-			state.activeJobs.clear();
-			state.errorCount = 0;
-			state.execution = createCounts();
-			state.progress = createProgress();
-			state.ruleGroups.clear();
-			state.runStartedAt = startedAt ?? now();
-			state.animationTick = 0;
-			state.cachedTokens = 0;
-			state.jobTokens.clear();
-			state.totalTokens = 0;
-			state.warnCount = 0;
-		},
-		onRunEnd: (payload) => {
-			state.warnCount = payload.diagnostics.filter((diagnostic) => diagnostic.severity === "warn").length;
-			state.errorCount = payload.diagnostics.length - state.warnCount;
-			updateProgress(state, payload.progress);
-			state.totalTokens = payload.usage.totalTokens;
-			state.cachedTokens = payload.usage.cached?.totalTokens ?? 0;
-			state.runStartedAt = payload.startedAt ?? state.runStartedAt;
-		},
-		onUsage: ({ job, progress, record }) => {
-			updateProgress(state, progress);
-			if (record.totalTokens != null && Number.isFinite(record.totalTokens)) {
-				state.jobTokens.set(job.id, (state.jobTokens.get(job.id) ?? 0) + record.totalTokens);
-				state.totalTokens += record.totalTokens;
-			}
-		},
-		/**
-		* Advances the summary animation on each renderer interval.
-		*
-		* Triggering workflow:
-		*
-		* `createTtyProgressRenderer`
-		*   -> `createCliProgressReporter` `createInterval` callback
-		*     -> `SummaryProgressReporter.tick` (this handler)
-		*
-		* Upstream:
-		* - `createCliProgressReporter` `createInterval` callback registered by `createTtyProgressRenderer`
-		*
-		* Downstream:
-		* - Increments `state.animationTick`, consumed by {@link createRows}, {@link formatSpinnerFrame}, and {@link formatMiniBarSegment}.
-		*/
-		tick: () => {
-			state.animationTick += 1;
-		}
+		runner,
+		setupConfig,
+		shutdown: () => shutdown ??= runtime.shutdown()
+	};
+}
+//#endregion
+//#region src/cli/commands/lint/changed-lines.ts
+/** Keeps file-wide diagnostics and diagnostics whose locations intersect the current Git change. */
+function filterResultToChangedLines(result, options) {
+	return {
+		...result,
+		diagnostics: result.diagnostics.filter((diagnostic) => {
+			if (diagnostic.loc === void 0) return true;
+			const changedLinesPath = (isAbsolute(diagnostic.filePath) ? relative(options.cwd, diagnostic.filePath) : diagnostic.filePath).replaceAll("\\", "/");
+			const ranges = options.changedLines.get(changedLinesPath);
+			if (ranges === void 0) return false;
+			const startLine = diagnostic.loc.start.line;
+			const endLine = diagnostic.loc.end?.line ?? startLine;
+			return ranges.some((range) => startLine <= range.endLine && endLine >= range.startLine);
+		})
+	};
+}
+//#endregion
+//#region src/cli/commands/lint/runner.ts
+/**
+* Applies this invocation's flags on top of the project's resolved runner.
+*
+* The setup/config merge itself lives in `runtime/runner.ts` because the language server needs the
+* same base without any flags; only the overrides below are CLI-shaped.
+*/
+function resolveRunnerConfig(baseRunner, options) {
+	const ruleConcurrency = parsePositiveIntegerOption(options.ruleConcurrency, "--rule-concurrency");
+	const timeoutMs = parsePositiveIntegerOption(options.timeoutMs, "--timeout-ms");
+	const runner = {
+		...baseRunner ?? {},
+		cache: resolveCacheOption(baseRunner?.cache, options),
+		ruleConcurrency: ruleConcurrency ?? baseRunner?.ruleConcurrency,
+		stats: options.stats === false ? false : baseRunner?.stats,
+		timeoutMs: timeoutMs ?? baseRunner?.timeoutMs
+	};
+	return Object.values(runner).some((value) => value !== void 0) ? runner : void 0;
+}
+function parsePositiveIntegerOption(value, label) {
+	if (value === void 0) return;
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${label} must be a positive integer.`);
+	return parsed;
+}
+function resolveCacheOption(baseCache, options) {
+	if (options.cache === false) return false;
+	if (options.cacheLocation !== void 0) return typeof baseCache === "object" ? {
+		...baseCache,
+		location: options.cacheLocation
+	} : { location: options.cacheLocation };
+	return baseCache;
+}
+//#endregion
+//#region src/cli/stats/ci.ts
+function isCi(env = process.env) {
+	const ci = env.CI;
+	if (ci !== void 0 && ci !== "" && ci !== "0" && ci !== "false") return true;
+	return Boolean(env.GITHUB_ACTIONS || env.GITLAB_CI || env.CIRCLECI || env.BUILDKITE || env.TF_BUILD);
+}
+//#endregion
+//#region src/cli/stats/since.ts
+/**
+* Parse a `--since` time into an inclusive lower-bound timestamp.
+*
+* Supported formats:
+* - `Nh`/`Nd`/`Nw`/`Nm`/`Ny` — now minus N hours/days/weeks/months/years.
+*   Weeks, months, and years are fixed approximations (7/30/365 days). `m` is
+*   months here, not minutes — a day is the finest window this tool tracks.
+* - `YYYY-MM`/`YYYY-MM-DD` — start of that UTC month/day.
+*
+* Edge cases:
+* - An empty time means "no lower bound".
+* - An unrecognized time throws.
+*/
+const HOUR_MS = 36e5;
+const UNIT_MS = {
+	d: 24 * HOUR_MS,
+	h: HOUR_MS,
+	m: 720 * HOUR_MS,
+	w: 168 * HOUR_MS,
+	y: 8760 * HOUR_MS
+};
+function parseSince(time, now) {
+	if (time === void 0 || time === "") return;
+	const relative = /^(\d+)([dhmwy])$/u.exec(time);
+	if (relative) return now - Number(relative[1]) * UNIT_MS[relative[2]];
+	const calendar = /^(\d{4})-(\d{2})(?:-(\d{2}))?$/u.exec(time);
+	if (calendar) {
+		const year = Number(calendar[1]);
+		const month = Number(calendar[2]);
+		const day = calendar[3] === void 0 ? 1 : Number(calendar[3]);
+		return Date.UTC(year, month - 1, day);
+	}
+	throw new Error(`Invalid --since "${time}": use e.g. 24h, 7d, 2w, 3m, 1y, 2025-01, or 2025-01-15.`);
+}
+//#endregion
+//#region src/cli/stats/jsonl.ts
+const DEFAULT_RETENTION_MONTHS = 12;
+const STATS_FILE_PATTERN = /^stats-(\d{4})-(\d{2})\.jsonl$/u;
+const DAY_MS = 864e5;
+const MONTH_LABELS$1 = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+function createJsonlStatsStore(options) {
+	const retentionMonths = options.retentionMonths ?? DEFAULT_RETENTION_MONTHS;
+	return {
+		query: (filter) => query(options.dir, filter ?? {}, Date.now),
+		querySeries: (filter) => querySeries(options.dir, filter ?? {}, Date.now),
+		record: (input) => record(options.dir, input, Date.now(), retentionMonths)
 	};
 }
-function compareRuleGroups(left, right) {
-	const leftActive = left.jobs.some((job) => job.state === "running") ? 1 : 0;
-	const rightActive = right.jobs.some((job) => job.state === "running") ? 1 : 0;
-	if (leftActive !== rightActive) return rightActive - leftActive;
-	if (left.failed !== right.failed) return right.failed - left.failed;
-	return left.firstJobIndex - right.firstJobIndex;
+function accumulate(rows, key, inTok, outTok, totalTok, countRun) {
+	const row = rows.get(key) ?? {
+		inTok: 0,
+		key,
+		outTok: 0,
+		runs: 0,
+		totalTok: 0
+	};
+	row.inTok += inTok;
+	row.outTok += outTok;
+	row.totalTok += totalTok;
+	if (countRun) row.runs += 1;
+	rows.set(key, row);
+	return row;
 }
-function compareRunningJobs(left, right) {
-	const leftStartedAt = left.startedAt ?? Number.POSITIVE_INFINITY;
-	const rightStartedAt = right.startedAt ?? Number.POSITIVE_INFINITY;
-	if (leftStartedAt !== rightStartedAt) return leftStartedAt - rightStartedAt;
-	return left.job.index - right.job.index;
+function bucketLabel(startMs, interval) {
+	const date = new Date(startMs);
+	if (interval === "month") return MONTH_LABELS$1[date.getUTCMonth()];
+	return `${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}`;
 }
-function completeGraphemeBoundary(input, maximumIndex) {
-	let boundary = 0;
-	for (const segment of graphemeSegmenter.segment(input)) {
-		const end = segment.index + segment.segment.length;
-		if (end > maximumIndex) break;
-		boundary = end;
+function bucketStart(ts, interval) {
+	const date = new Date(ts);
+	if (interval === "month") return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1);
+	const dayStart = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+	if (interval === "week") return dayStart - (new Date(dayStart).getUTCDay() + 6) % 7 * DAY_MS;
+	return dayStart;
+}
+function chooseInterval(since, nowMs, timestamps) {
+	if (since !== void 0) return intervalForDuration(nowMs - since);
+	if (timestamps.length < 2) return "day";
+	return intervalForDuration(Math.max(...timestamps) - Math.min(...timestamps));
+}
+function fillBuckets(buckets, interval) {
+	if (buckets.size === 0) return [];
+	const starts = [...buckets.keys()].sort((left, right) => left - right);
+	const last = starts.at(-1);
+	const filled = [];
+	for (let startMs = starts[0]; startMs <= last; startMs = nextBucketStart(startMs, interval)) filled.push(buckets.get(startMs) ?? {
+		inTok: 0,
+		key: bucketLabel(startMs, interval),
+		outTok: 0,
+		runs: 0,
+		startMs,
+		totalTok: 0
+	});
+	return filled;
+}
+function intervalForDuration(ms) {
+	const days = ms / DAY_MS;
+	if (days <= 21) return "day";
+	if (days <= 120) return "week";
+	return "month";
+}
+function isEnoent(error) {
+	return error instanceof Error && error.code === "ENOENT";
+}
+function monthIndexOf(ts) {
+	const date = new Date(ts);
+	return date.getUTCFullYear() * 12 + date.getUTCMonth();
+}
+function nextBucketStart(startMs, interval) {
+	if (interval === "month") {
+		const date = new Date(startMs);
+		return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1);
 	}
-	return boundary;
+	return startMs + (interval === "week" ? 7 * DAY_MS : DAY_MS);
 }
-function createCounts(planned = 0) {
-	return {
-		cached: 0,
-		cancelled: 0,
-		completed: 0,
-		failed: 0,
-		planned,
-		queued: 0,
-		running: 0,
-		skipped: 0
-	};
+function parseRunLine(line) {
+	try {
+		const value = JSON.parse(line);
+		if (typeof value.ts === "number" && typeof value.cwd === "string" && value.usage != null) return value;
+		return;
+	} catch {
+		return;
+	}
 }
-function createInitialState() {
-	return {
-		activeJobs: /* @__PURE__ */ new Map(),
-		animationTick: 0,
-		cachedTokens: 0,
-		errorCount: 0,
-		execution: createCounts(),
-		jobTokens: /* @__PURE__ */ new Map(),
-		progress: createProgress(),
-		ruleGroups: /* @__PURE__ */ new Map(),
-		totalTokens: 0,
-		warnCount: 0
-	};
+async function prune(dir, ts, retentionMonths) {
+	if (retentionMonths <= 0) return;
+	const cutoff = monthIndexOf(ts) - (retentionMonths - 1);
+	const files = await statsFiles(dir);
+	for (const { month, name } of files) if (month < cutoff) await rm(join(dir, name));
 }
-function createProgress() {
+async function query(dir, filter, now) {
+	const dimension = filter.by ?? "model";
+	const since = parseSince(filter.since, now());
+	const rules = ruleSet(filter.rules);
+	const runs = await readRuns(dir);
+	const rows = /* @__PURE__ */ new Map();
+	let totalRuns = 0;
+	let totalIn = 0;
+	let totalOut = 0;
+	let totalTok = 0;
+	for (const run of runs) {
+		if (!runInWindow(run, since, filter.cwd)) continue;
+		const slice = sliceRun(run, rules);
+		if (!slice.touched) continue;
+		totalRuns += 1;
+		totalIn += slice.inTok;
+		totalOut += slice.outTok;
+		totalTok += slice.totalTok;
+		if (dimension === "dir") {
+			accumulate(rows, run.cwd, slice.inTok, slice.outTok, slice.totalTok, true);
+			continue;
+		}
+		const seenKeys = /* @__PURE__ */ new Set();
+		for (const usageRecord of slice.usageRecords) {
+			const key = recordKey(usageRecord, dimension);
+			accumulate(rows, key, usageRecord.inTok, usageRecord.outTok, usageRecord.totalTok, !seenKeys.has(key));
+			seenKeys.add(key);
+		}
+	}
 	return {
-		execution: createCounts(),
-		filesPlanned: 0,
-		filesTotal: 0,
-		jobsCompleted: 0,
-		jobsStarted: 0,
-		jobsTotal: 0,
-		planningComplete: false
+		dimension,
+		rows: [...rows.values()].sort((left, right) => right.totalTok - left.totalTok),
+		totalIn,
+		totalOut,
+		totalRuns,
+		totalTok
 	};
 }
-function createRows(state, options, now) {
-	if (options.rows !== void 0 && options.rows <= 0) return [];
-	const groups = createRuleGroups(state);
-	const footerRows = options.rows === void 0 ? 3 : Math.min(options.rows, 3);
-	const separatorRows = options.rows === void 0 || options.rows - footerRows > 1 ? 1 : 0;
-	const visible = formatContentRows(groups, state, options, now, options.rows === void 0 ? Number.POSITIVE_INFINITY : Math.max(options.rows - footerRows - separatorRows, 0));
-	const footer = formatFooters(state, options, now);
-	const actualSeparatorRows = visible.length > 0 ? separatorRows : 0;
-	const visibleFooters = options.rows === void 0 ? footer : footer.slice(0, Math.max(options.rows - visible.length - actualSeparatorRows, 0));
-	if (actualSeparatorRows === 1) visible.push("");
-	visible.push(...visibleFooters);
-	return options.color ? visible.map((row) => styleRow(row, state, state.warnCount, state.errorCount, options)) : visible;
-}
-function createRuleGroup(job) {
+async function querySeries(dir, filter, now) {
+	const nowMs = now();
+	const since = parseSince(filter.since, nowMs);
+	const rules = ruleSet(filter.rules);
+	const runs = await readRuns(dir);
+	const sliced = [];
+	for (const run of runs) {
+		if (!runInWindow(run, since, filter.cwd)) continue;
+		const slice = sliceRun(run, rules);
+		if (slice.touched) sliced.push({
+			slice,
+			ts: run.ts
+		});
+	}
+	const interval = filter.interval ?? chooseInterval(since, nowMs, sliced.map((entry) => entry.ts));
+	const buckets = /* @__PURE__ */ new Map();
+	let totalRuns = 0;
+	let totalIn = 0;
+	let totalOut = 0;
+	let totalTok = 0;
+	for (const { slice, ts } of sliced) {
+		const startMs = bucketStart(ts, interval);
+		const bucket = buckets.get(startMs) ?? {
+			inTok: 0,
+			key: bucketLabel(startMs, interval),
+			outTok: 0,
+			runs: 0,
+			startMs,
+			totalTok: 0
+		};
+		bucket.runs += 1;
+		bucket.inTok += slice.inTok;
+		bucket.outTok += slice.outTok;
+		bucket.totalTok += slice.totalTok;
+		buckets.set(startMs, bucket);
+		totalRuns += 1;
+		totalIn += slice.inTok;
+		totalOut += slice.outTok;
+		totalTok += slice.totalTok;
+	}
 	return {
-		cached: 0,
-		cancelled: 0,
-		completed: 0,
-		failed: 0,
-		firstJobIndex: job.index,
-		planned: 0,
-		ruleId: job.ruleId,
-		skipped: 0,
-		terminalDurationMs: 0
+		buckets: fillBuckets(buckets, interval),
+		interval,
+		totalIn,
+		totalOut,
+		totalRuns,
+		totalTok
 	};
 }
-function createRuleGroups(state) {
-	const groups = new Map([...state.ruleGroups].map(([ruleId, group]) => [ruleId, {
-		...group,
-		jobs: []
-	}]));
-	for (const job of state.activeJobs.values()) groups.get(job.job.ruleId)?.jobs.push(job);
-	return [...groups.values()].sort(compareRuleGroups);
-}
-function estimateEta(durationMs, terminal, planned) {
-	if (terminal <= 0 || planned <= 0 || durationMs <= 0) return "eta ?";
-	return `eta ~${formatDuration$1(durationMs * (planned - terminal) / terminal)}`;
-}
-function fitRow(row, columns) {
-	if (columns <= 0) return "";
-	if (fastStringWidth(row) <= columns) return row;
-	let limit = columns;
-	while (limit > 0) {
-		const result = fastStringTruncatedWidth(row, {
-			ellipsis: "…",
-			limit
-		});
-		const index = completeGraphemeBoundary(row, result.index);
-		const visible = row.slice(0, index);
-		const fitted = `${visible}${visible.includes("\x1B") ? "\x1B[0m" : ""}${result.ellipsed ? "…" : ""}`;
-		const overflow = fastStringWidth(fitted) - columns;
-		if (overflow <= 0) return fitted;
-		limit -= overflow;
+async function readRuns(dir) {
+	const files = await statsFiles(dir);
+	const runs = [];
+	for (const { name } of files) {
+		const content = await readFile(join(dir, name), "utf8");
+		for (const line of content.split("\n")) {
+			if (line.trim() === "") continue;
+			const run = parseRunLine(line);
+			if (run) runs.push(run);
+		}
 	}
-	return "";
+	return runs;
 }
-function formatCollapsedRunningRow(hidden, options) {
-	return fitRow(`   └─ ${hidden} more running`, options.columns);
+async function record(dir, input, ts, retentionMonths) {
+	const stat = {
+		ts,
+		...input
+	};
+	await mkdir(dir, { recursive: true });
+	await appendFile(join(dir, statsFileName(ts)), `${JSON.stringify(stat)}\n`, "utf8");
+	await prune(dir, ts, retentionMonths);
 }
-function formatContentRows(groups, state, options, now, contentBudget) {
-	const rows = [];
-	const renderableGroups = groups.filter((group) => group.jobs.some((job) => job.state === "running") || group.failed > 0);
-	const runningCount = renderableGroups.reduce((sum, group) => sum + group.jobs.filter((job) => job.state === "running").length, 0);
-	if (contentBudget === 1) {
-		const failedGroup = renderableGroups.find((group) => group.failed > 0);
-		if (failedGroup) return [formatRuleRow(failedGroup, state, options)];
-		if (runningCount > 0) return [formatCollapsedRunningRow(runningCount, options)];
-	}
-	for (const [groupIndex, group] of renderableGroups.entries()) {
-		if (rows.length >= contentBudget) break;
-		const groupStart = rows.length;
-		rows.push(formatRuleRow(group, state, options));
-		const runningJobs = group.jobs.filter((job) => job.state === "running").sort(compareRunningJobs);
-		const remainingGroups = renderableGroups.length - groupIndex - 1;
-		for (const [index, job] of runningJobs.entries()) {
-			const rowsReservedForLaterGroups = Math.min(remainingGroups, Math.max(contentBudget - rows.length, 0));
-			if (rows.length >= contentBudget) {
-				const hidden = runningJobs.length - index;
-				if (rows.length > groupStart + 1 && hidden > 0) rows[rows.length - 1] = formatCollapsedRunningRow(hidden, options);
-				break;
-			}
-			if (rows.length + 1 + rowsReservedForLaterGroups >= contentBudget) {
-				if (runningJobs.length > 1) rows.push(formatCollapsedRunningRow(runningJobs.length - index, options));
-				break;
-			}
-			rows.push(formatTargetRow(job, options, now, index === runningJobs.length - 1));
-		}
-	}
-	return rows;
+function recordKey(record, dimension) {
+	if (dimension === "rule") return record.ruleId;
+	if (dimension === "operation") return record.operation ?? record.ruleId;
+	return `${record.providerId}/${record.modelId}`;
 }
-function formatDuration$1(ms) {
-	const durationMs = Math.max(ms, 0);
-	if (durationMs < 6e4) return `${(durationMs / 1e3).toFixed(1)}s`;
-	return formatDuration(intervalToDuration({
-		end: durationMs,
-		start: 0
-	}));
+function ruleSet(rules) {
+	return rules && rules.length > 0 ? new Set(rules) : void 0;
 }
-function formatFooters(state, options, now) {
-	const terminal = terminalCount(state.execution);
-	const elapsed = state.runStartedAt === void 0 ? 0 : now - state.runStartedAt;
-	const progressBar = state.progress.planningComplete ? formatMiniBarSegment(terminal, state.execution.planned, state.animationTick, options) : "";
-	const eta = state.progress.planningComplete ? estimateEta(elapsed, terminal, state.execution.planned) : "eta ?";
-	const projectedTokens = state.progress.planningComplete && terminal > 0 && state.execution.planned > 0 ? Math.ceil((state.totalTokens + state.cachedTokens) * state.execution.planned / terminal) : void 0;
-	const discovering = state.progress.planningComplete ? "" : " jobs (discovering)";
-	return [
-		fitRow(`${terminal}/${state.execution.planned}${discovering}${progressBar} ${formatDuration$1(elapsed)} -> ${eta === "eta ?" ? "~?" : eta.replace("eta ", "")}`, options.columns),
-		fitRow(`${state.execution.running} concurrency / ${state.execution.queued} queued / ${state.execution.cached} cached / ${state.execution.failed} failed`, options.columns),
-		fitRow(`${state.totalTokens.toLocaleString("en-US")} tokens (${state.cachedTokens.toLocaleString("en-US")} cached) -> ${projectedTokens === void 0 ? "~?" : `~${projectedTokens.toLocaleString("en-US")} tokens`}`, options.columns)
-	];
+function runInWindow(run, since, cwd) {
+	return (since === void 0 || run.ts >= since) && (cwd === void 0 || run.cwd === cwd);
 }
-function formatMiniBarSegment(completed, planned, tick, options) {
-	if (options.columns < 60) return "";
-	return ` ${formatMiniBar({
-		completed,
-		planned,
-		tick,
-		width: 10
-	})}`;
+function sliceRun(run, rules) {
+	if (rules === void 0) return {
+		inTok: run.usage.inTok,
+		outTok: run.usage.outTok,
+		totalTok: run.usage.totalTok,
+		touched: true,
+		usageRecords: run.usage.records
+	};
+	const usageRecords = run.usage.records.filter((record) => rules.has(record.ruleId));
+	return {
+		inTok: sumBy(usageRecords, (record) => record.inTok),
+		outTok: sumBy(usageRecords, (record) => record.outTok),
+		totalTok: sumBy(usageRecords, (record) => record.totalTok),
+		touched: usageRecords.length > 0,
+		usageRecords
+	};
 }
-function formatRuleRow(group, state, options) {
-	const spinner = formatSpinnerFrame(state.animationTick, options.spinnerFrames);
-	const terminal = group.completed + group.cached + group.failed + group.cancelled + group.skipped;
-	const percent = group.planned > 0 ? Math.floor(terminal / group.planned * 100) : 0;
-	const bar = formatMiniBarSegment(terminal, group.planned, state.animationTick, options);
-	const running = group.jobs.filter((job) => job.state === "running").length;
-	const failed = group.failed > 0 ? ` ${group.failed} failed` : "";
-	const eta = estimateEta(group.terminalDurationMs, terminal, group.planned);
-	return fitRow(`${spinner} ${group.ruleId} ${terminal}/${group.planned} ${percent}%${bar} ${eta} ${running} running${failed}`, options.columns);
+function statsFileName(ts) {
+	const date = new Date(ts);
+	return `stats-${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}.jsonl`;
 }
-function formatSpinnerFrame(animationTick, spinnerFrames) {
-	return spinnerFrames[animationTick % Math.max(spinnerFrames.length, 1)] ?? "";
+async function statsFiles(dir) {
+	let entries;
+	try {
+		entries = await readdir(dir);
+	} catch (error) {
+		if (isEnoent(error)) return [];
+		throw error;
+	}
+	return entries.map((name) => {
+		const match = STATS_FILE_PATTERN.exec(name);
+		return match ? {
+			month: Number(match[1]) * 12 + (Number(match[2]) - 1),
+			name
+		} : void 0;
+	}).filter((entry) => entry !== void 0).sort((left, right) => left.month - right.month);
 }
-function formatTargetRow(jobState, options, now, last) {
-	const inputPath = options.cwd ? relative$1(options.cwd, jobState.job.inputPath) || "." : jobState.job.inputPath;
-	const target = jobState.job.target.name ? `${jobState.job.target.kind} ${jobState.job.target.name}` : jobState.job.target.kind;
-	const startedAt = jobState.retry?.startedAt ?? jobState.startedAt ?? now;
-	return fitRow(`${last ? "   └─" : "   ├─"} ${inputPath} > ${target} ${jobState.retry ? `${jobState.retry.attempt}/${jobState.retry.maxAttempts} retrying elapsed ${formatDuration$1(now - startedAt)}` : `running ${formatDuration$1(now - startedAt)}`}`, options.columns);
+function sumBy(items, select) {
+	let total = 0;
+	for (const item of items) total += select(item);
+	return total;
 }
-function styleRow(row, state, warnCount, errorCount, options) {
-	let styledRow = row;
-	const spinner = formatSpinnerFrame(state.animationTick, options.spinnerFrames);
-	if (spinner) styledRow = styledRow.replace(spinner, colors$2.cyan(spinner));
-	return styledRow.replace(`${state.execution.running} concurrency`, colors$2.cyan(`${state.execution.running} concurrency`)).replace(`${state.totalTokens.toLocaleString("en-US")} tokens`, colors$2.cyan(`${state.totalTokens.toLocaleString("en-US")} tokens`)).replace(`(${state.cachedTokens.toLocaleString("en-US")} cached)`, colors$2.dim(`(${state.cachedTokens.toLocaleString("en-US")} cached)`)).replace(` / ${state.execution.cached} cached / `, ` / ${colors$2.dim(`${state.execution.cached} cached`)} / `).replace(`${warnCount} warn`, colors$2.yellow(`${warnCount} warn`)).replace(`${errorCount} error`, (errorCount > 0 ? colors$2.red : colors$2.gray)(`${errorCount} error`)).replace(`${state.execution.failed} failed`, (state.execution.failed > 0 ? colors$2.red : colors$2.gray)(`${state.execution.failed} failed`)).replace(/\[([█▓░]*?)(░+)\]/g, (_, active, pending) => `[${active}${colors$2.gray(pending)}]`).replace(/\//g, colors$2.gray("/"));
+//#endregion
+//#region src/cli/stats/record.ts
+function createRunStat(input) {
+	return {
+		cwd: input.cwd,
+		durationMs: input.durationMs,
+		ruleCounts: input.ruleCounts,
+		usage: {
+			inTok: input.usage.inputTokens,
+			outTok: input.usage.outputTokens,
+			records: input.usage.records.map(toStatsUsageRecord),
+			totalTok: input.usage.totalTokens
+		}
+	};
 }
-function terminalCount(counts) {
-	return counts.completed + counts.failed + counts.cached + counts.skipped + counts.cancelled;
+function readOperation(metadata) {
+	if (typeof metadata !== "object" || metadata === null || !("operation" in metadata)) return;
+	const operation = metadata.operation;
+	return typeof operation === "string" ? operation : void 0;
 }
-function updateProgress(state, progress) {
-	state.execution = { ...progress.execution };
-	state.progress = {
-		...progress,
-		execution: { ...progress.execution }
+function toStatsUsageRecord(record) {
+	return {
+		filePath: record.filePath,
+		inTok: record.inputTokens ?? 0,
+		modelId: record.modelId,
+		operation: readOperation(record.metadata),
+		outTok: record.outputTokens ?? 0,
+		providerId: record.providerId,
+		ruleId: record.ruleId,
+		totalTok: record.totalTokens ?? 0
 	};
 }
 //#endregion
-//#region src/cli/reporters/progress/tty.ts
-const clearCurrentLine = "\r\x1B[K";
-const clearPreviousLine = "\r\x1B[1A\x1B[K";
-function createTtyProgressRenderer(options) {
-	let interval;
-	let previousRows = 0;
-	const clearPreviousFrame = () => {
-		if (previousRows === 0) return;
-		let sequence = clearCurrentLine;
-		for (let row = 1; row < previousRows; row += 1) sequence += clearPreviousLine;
-		options.write(sequence);
-		previousRows = 0;
-	};
-	const render = () => {
-		clearPreviousFrame();
-		const rows = options.getRows();
-		if (rows.length === 0) return;
-		options.write(rows.join("\n"));
-		previousRows = rows.length;
-	};
-	const write = (chunk) => {
-		const wasRendering = interval !== void 0;
-		clearPreviousFrame();
-		options.write(chunk);
-		if (wasRendering) render();
+//#region src/cli/commands/lint/stats.ts
+function createStatsCollector() {
+	const counts = {
+		cached: 0,
+		cancelled: 0,
+		completed: 0,
+		failed: 0,
+		planned: 0
 	};
+	let startedAt;
+	let endedAt;
 	return {
-		finish: () => {
-			if (interval) {
-				options.clearInterval(interval);
-				interval = void 0;
-			}
-			clearPreviousFrame();
-		},
-		render,
-		start: () => {
-			if (!interval) {
-				interval = options.createInterval(render, options.intervalMs);
-				if (isUnrefableInterval(interval)) interval.unref();
+		counts,
+		durationMs: () => startedAt !== void 0 && endedAt !== void 0 ? endedAt - startedAt : void 0,
+		reporter: {
+			onPrepareStart: (payload) => {
+				startedAt = payload.startedAt;
+			},
+			onRunEnd: (payload) => {
+				counts.cached = payload.execution.cached;
+				counts.cancelled = payload.execution.cancelled;
+				counts.completed = payload.execution.completed;
+				counts.failed = payload.execution.failed;
+				counts.planned = payload.execution.planned;
+				endedAt = payload.endedAt;
 			}
-			render();
-		},
-		write
+		}
 	};
 }
-function isUnrefableInterval(interval) {
-	if (typeof interval !== "object" || interval === null || !("unref" in interval)) return false;
-	return typeof interval.unref === "function";
-}
-//#endregion
-//#region src/cli/reporters/progress/index.ts
-function createCliProgressReporter(options) {
-	if (!options.isTty) return {
-		dispose: () => {},
-		reporter: createPlainProgressReporter({ write: options.write }),
-		write: options.write
+function mergeProgressReporters(base, extra) {
+	if (!base) return extra;
+	if (!extra) return base;
+	const baseState = {
+		disabled: false,
+		reporter: base
 	};
-	const summary = createSummaryProgressReporter({
-		color: options.color,
-		columns: options.columns,
-		cwd: options.cwd,
-		rows: options.rows,
-		spinnerFrames: cliSpinners.dots.frames
-	});
-	const renderer = createTtyProgressRenderer({
-		clearInterval: (handle) => globalThis.clearInterval(handle),
-		createInterval: (callback, intervalMs) => globalThis.setInterval(() => {
-			summary.tick();
-			callback();
-		}, intervalMs),
-		getRows: summary.getRows,
-		intervalMs: 120,
-		write: options.write
-	});
-	const reporter = createRenderingProgressReporter(summary, renderer);
-	return {
-		dispose: renderer.finish,
-		reporter,
-		write: renderer.write
+	const extraState = {
+		disabled: false,
+		reporter: extra
+	};
+	let firstFailure;
+	const deliver = (state, callback) => {
+		if (state.disabled) return;
+		try {
+			callback(state.reporter);
+		} catch (error) {
+			state.disabled = true;
+			firstFailure ??= normalizeReporterError(error);
+		}
+	};
+	const deliverBoth = (callback) => {
+		deliver(baseState, callback);
+		deliver(extraState, callback);
 	};
-}
-function createRenderingProgressReporter(summary, renderer) {
 	return {
 		onDiagnostic: (payload) => {
-			summary.onDiagnostic?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onDiagnostic?.(payload));
 		},
 		onExecuteEnd: (payload) => {
-			summary.onExecuteEnd?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onExecuteEnd?.(payload));
 		},
 		onExecuteStart: (payload) => {
-			summary.onExecuteStart?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onExecuteStart?.(payload));
 		},
 		onFileReady: (payload) => {
-			summary.onFileReady?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onFileReady?.(payload));
 		},
 		onJobEnd: (payload) => {
-			summary.onJobEnd?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onJobEnd?.(payload));
 		},
 		onJobQueued: (payload) => {
-			summary.onJobQueued?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onJobQueued?.(payload));
 		},
 		onJobRetry: (payload) => {
-			summary.onJobRetry?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onJobRetry?.(payload));
 		},
 		onJobStart: (payload) => {
-			summary.onJobStart?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onJobStart?.(payload));
+		},
+		onPlanningEnd: (payload) => {
+			deliverBoth((reporter) => reporter.onPlanningEnd?.(payload));
 		},
 		onPrepareEnd: (payload) => {
-			summary.onPrepareEnd?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onPrepareEnd?.(payload));
 		},
 		onPrepareStart: (payload) => {
-			summary.onPrepareStart?.(payload);
-			renderer.start();
+			deliverBoth((reporter) => reporter.onPrepareStart?.(payload));
 		},
 		onRunEnd: (payload) => {
-			summary.onRunEnd?.(payload);
-			renderer.render();
+			deliverBoth((reporter) => reporter.onRunEnd?.(payload));
+			if (firstFailure) throw firstFailure;
 		},
 		onUsage: (payload) => {
-			summary.onUsage?.(payload);
-			renderer.render();
-		}
-	};
-}
-//#endregion
-//#region src/cli/commands/lint/discovery.ts
-const minimatchOptions = { dot: true };
-const directoryBufferSize = 256;
-var NoFilesFoundError = class extends Error {
-	globInputPaths;
-	pattern;
-	constructor(pattern, options) {
-		super(`No files matching "${pattern}" were found${options.globInputPaths ? "" : " (glob input is disabled)"}.`);
-		this.name = "NoFilesFoundError";
-		this.globInputPaths = options.globInputPaths;
-		this.pattern = pattern;
-	}
-};
-async function findLintTargets(options) {
-	const { config, cwd, errorOnUnmatchedPattern = true, globInputPaths = true, inputs } = options;
-	const gitignore = shouldFilterGitignoredFiles(config) ? new Gitignore() : void 0;
-	const targets = await resolveInputFiles({
-		config,
-		cwd,
-		errorOnUnmatchedPattern,
-		gitignore,
-		globInputPaths,
-		inputs: inputs.length > 0 ? inputs : ["."]
-	});
-	if (!gitignore || targets.files.length === 0) return targets;
-	const lintFiles = [];
-	for (const file of targets.files) {
-		if (await gitignore.ignores(resolve(cwd, file))) continue;
-		lintFiles.push(file);
-	}
-	return {
-		directories: targets.directories,
-		files: lintFiles
-	};
-}
-function collectGlobalIgnorePatterns(config) {
-	return normalizeConfig(config).flatMap((item) => isGlobalIgnoreItem(item) ? [...item.ignores] : []);
-}
-function getGlobParent(input) {
-	const segments = input.replaceAll("\\", "/").split("/");
-	const parentSegments = [];
-	for (const segment of segments) {
-		if (isGlobPattern(segment)) break;
-		parentSegments.push(segment);
-	}
-	const parent = parentSegments.join("/");
-	return parent === "" ? "." : parent;
-}
-function isGlobalIgnoreItem(item) {
-	const keys = Object.keys(item).filter((key) => item[key] !== void 0);
-	return item.ignores !== void 0 && keys.every((key) => key === "ignores" || key === "name");
-}
-function isGlobPattern(input) {
-	return new Minimatch(input, minimatchOptions).hasMagic();
-}
-function isNodeError$1(error) {
-	return error instanceof Error && "code" in error;
-}
-function matchesGlob(filePath, pattern) {
-	return minimatch(filePath, pattern.replaceAll("\\", "/"), minimatchOptions);
-}
-function matchesIgnoredDirectory(relativePath, patterns) {
-	return patterns.some((pattern) => minimatch(relativePath, pattern, minimatchOptions) || minimatch(`${relativePath}/`, pattern, minimatchOptions) || minimatch(`${relativePath}/__alint__`, pattern, minimatchOptions));
-}
-function normalizeGlobPattern(cwd, pattern) {
-	return isAbsolute(pattern) ? normalizeRelativePath(cwd, pattern) : pattern.replaceAll("\\", "/");
-}
-function normalizeRelativePath(cwd, filePath) {
-	return relative(cwd, filePath).replaceAll("\\", "/");
-}
-async function resolveInputFiles(options) {
-	const hasFilePatterns = hasDiscoveryFilePatterns(options.config);
-	const ignoredPatterns = collectGlobalIgnorePatterns(options.config);
-	const candidates = [];
-	const directories = [];
-	for (const input of options.inputs) {
-		const path = resolve(options.cwd, input);
-		const stats = await statPath(path);
-		if (stats?.isFile()) {
-			candidates.push(input);
-			continue;
-		}
-		if (stats?.isDirectory()) {
-			if (await shouldPruneDirectory(path, {
-				cwd: options.cwd,
-				gitignore: options.gitignore,
-				ignoredPatterns
-			})) continue;
-			directories.push(input);
-			if (!hasFilePatterns) continue;
-			const directoryFiles = [];
-			for await (const file of walkFiles(path, {
-				cwd: options.cwd,
-				gitignore: options.gitignore,
-				ignoredPatterns
-			})) {
-				const relativePath = normalizeRelativePath(options.cwd, file);
-				if (hasFilePatterns && matchesDiscoveryFile(relativePath, options.config, { cwd: options.cwd })) directoryFiles.push(relativePath);
-			}
-			for (const file of directoryFiles.sort()) candidates.push(file);
-			continue;
-		}
-		if (options.globInputPaths && isGlobPattern(input)) {
-			const matches = await searchGlob({
-				config: options.config,
-				cwd: options.cwd,
-				gitignore: options.gitignore,
-				hasFilePatterns,
-				ignoredPatterns,
-				pattern: input
-			});
-			if (matches.length === 0 && options.errorOnUnmatchedPattern) throw new NoFilesFoundError(input, { globInputPaths: options.globInputPaths });
-			for (const match of matches) candidates.push(match);
-			continue;
+			deliverBoth((reporter) => reporter.onUsage?.(payload));
 		}
-		if (options.errorOnUnmatchedPattern) throw new NoFilesFoundError(input, { globInputPaths: options.globInputPaths });
-	}
-	return {
-		directories: [...new Set(directories)],
-		files: [...new Set(candidates)]
-	};
-}
-async function searchGlob(options) {
-	const root = resolve(options.cwd, getGlobParent(options.pattern));
-	const rootStats = await statPath(root);
-	const pattern = normalizeGlobPattern(options.cwd, options.pattern);
-	if (!rootStats?.isDirectory()) return [];
-	const candidates = [];
-	for await (const file of walkFiles(root, {
-		cwd: options.cwd,
-		gitignore: options.gitignore,
-		ignoredPatterns: options.ignoredPatterns
-	})) {
-		const relativePath = normalizeRelativePath(options.cwd, file);
-		if (matchesGlob(relativePath, pattern) && shouldIncludeGlobCandidate(relativePath, options.config, {
-			cwd: options.cwd,
-			hasFilePatterns: options.hasFilePatterns
-		})) candidates.push(relativePath);
-	}
-	return candidates.sort();
+	};
 }
-function shouldFilterGitignoredFiles(config) {
-	return normalizeConfig(config).some((item) => item.ignore?.gitignore === true);
+function resolveStatsWrite(stats, env) {
+	if (isCi(env)) return;
+	if (!(stats === false ? false : stats === void 0 || stats === true ? true : stats.enabled !== false)) return;
+	const config = typeof stats === "object" ? stats : void 0;
+	return {
+		dir: config?.location ?? getStatsDir(env),
+		retentionMonths: config?.retentionMonths
+	};
 }
-function shouldIncludeGlobCandidate(filePath, config, options) {
-	if (options.hasFilePatterns) return matchesDiscoveryFile(filePath, config, { cwd: options.cwd });
-	return !resolveConfigForFile(filePath, config, { cwd: options.cwd }).ignored;
+async function writeRunStats(target, collector, result, cwd) {
+	const store = createJsonlStatsStore({
+		dir: target.dir,
+		retentionMonths: target.retentionMonths
+	});
+	try {
+		await store.record(createRunStat({
+			cwd,
+			durationMs: collector.durationMs(),
+			ruleCounts: {
+				cached: result.execution.cached,
+				cancelled: result.execution.cancelled,
+				completed: result.execution.completed,
+				failed: result.execution.failed,
+				planned: result.execution.planned
+			},
+			usage: result.usage
+		}));
+	} catch {}
 }
-async function shouldPruneDirectory(path, options) {
-	if (matchesIgnoredDirectory(normalizeRelativePath(options.cwd, path), options.ignoredPatterns)) return true;
-	return await options.gitignore?.ignores(`${path}/`) === true;
+function normalizeReporterError(error) {
+	if (error instanceof Error) return error;
+	return new Error(error != null ? String(error) : "Unknown progress reporter error.");
 }
-async function statPath(path) {
+//#endregion
+//#region src/cli/commands/lint/execution.ts
+/** Runs one session while keeping CLI flags and stats behavior identical for every caller. */
+async function executeLint(options) {
+	const runner = resolveRunnerConfig(options.session.runner, options.runnerOptions);
+	const statsTarget = resolveStatsWrite(runner?.stats, options.io.env);
+	const statsCollector = statsTarget ? createStatsCollector() : void 0;
+	const persistStats = async (result) => {
+		if (statsTarget && statsCollector) await writeRunStats(statsTarget, statsCollector, result, options.session.cwd);
+	};
+	const targetSelection = options.targets === void 0 ? { inputs: options.inputs } : { targets: options.targets };
+	let result;
 	try {
-		return await stat(path);
+		result = await options.session.run({
+			...targetSelection,
+			cacheOnly: options.cacheOnly,
+			modelOverride: options.modelOverride,
+			outputLanguage: options.outputLanguage,
+			progress: mergeProgressReporters(options.progress, statsCollector?.reporter),
+			runner,
+			signal: options.createSignal?.()
+		});
 	} catch (error) {
-		if (isNodeError$1(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) return;
+		if (error instanceof AlintRunError || error instanceof AlintRunCancelledError || error instanceof AlintCachePersistenceError) await persistStats(error.result);
 		throw error;
 	}
+	await persistStats(result);
+	return result;
 }
+//#endregion
+//#region src/cli/commands/integrations/stop-gate/timeout.ts
+const maximumTimerChunkMs = 2147483647;
 /**
-* Streams directory entries so unmatched trees never accumulate into recursive child arrays.
-* The consumer owns result ordering because filesystem iteration order is not stable.
+* Node shortens an overflowing timer to one millisecond. The public Stop Gate limit is currently
+* below that boundary, while chunking here keeps this process-level safety helper correct if the
+* host budget changes independently later.
 */
-async function* walkFiles(root, options) {
-	const pendingDirectories = [root];
-	while (pendingDirectories.length > 0) {
-		const currentDirectory = pendingDirectories.pop();
-		if (currentDirectory === void 0) continue;
-		const childDirectories = [];
-		const directory = await opendir(currentDirectory, { bufferSize: directoryBufferSize });
-		for await (const entry of directory) {
-			const path = resolve(currentDirectory, entry.name);
-			if (entry.isDirectory()) {
-				if (!await shouldPruneDirectory(path, options)) childDirectories.push(path);
-				continue;
+function createTimeoutSignal(timeoutMs) {
+	const controller = new AbortController();
+	let remainingMs = timeoutMs;
+	let timer;
+	const schedule = () => {
+		const delay = Math.min(remainingMs, maximumTimerChunkMs);
+		timer = setTimeout(() => {
+			remainingMs -= delay;
+			if (remainingMs > 0) {
+				schedule();
+				return;
 			}
-			if (entry.isFile()) yield path;
+			controller.abort(new DOMException("Stop Gate timed out.", "TimeoutError"));
+		}, delay);
+	};
+	schedule();
+	return {
+		dispose: () => clearTimeout(timer),
+		signal: controller.signal
+	};
+}
+//#endregion
+//#region src/cli/commands/integrations/stop-gate/run.ts
+async function runStopGateLint(options) {
+	const dirtyTargets = options.stopGate.target === "dirty-files" ? await findDirtyLintTargets(options.config, options.cwd) : void 0;
+	const targets = dirtyTargets ?? await findLintTargets({
+		config: options.config,
+		cwd: options.cwd,
+		errorOnUnmatchedPattern: true,
+		globInputPaths: true,
+		inputs: ["."]
+	});
+	if (options.stopGate.target === "dirty-files" && targets.files.length === 0) return;
+	const session = await createRunSession({
+		...options.io,
+		cwd: options.cwd
+	}, { config: options.config });
+	let timeout;
+	try {
+		let result;
+		let runError;
+		try {
+			result = await executeLint({
+				createSignal: () => {
+					timeout = createTimeoutSignal(options.stopGate.timeoutMs);
+					return timeout.signal;
+				},
+				io: options.io,
+				runnerOptions: { format: "json" },
+				session,
+				targets
+			});
+		} catch (error) {
+			if (!(error instanceof AlintRunError)) throw error;
+			runError = error;
+			result = error.result;
 		}
-		for (const path of childDirectories.reverse()) pendingDirectories.push(path);
+		if (dirtyTargets !== void 0) result = filterResultToChangedLines(result, {
+			changedLines: dirtyTargets.changedLines,
+			cwd: options.cwd
+		});
+		return runError === void 0 ? {
+			files: targets.files,
+			result
+		} : {
+			error: runError,
+			files: targets.files,
+			result
+		};
+	} finally {
+		timeout?.dispose();
+		await session.shutdown();
 	}
 }
 //#endregion
-//#region src/cli/runtime/runner.ts
-/**
-* Merges the setup config runner with the project config runner. No CLI flag is applied.
-*
-* `runner.cache` selects the cache file. The lint command and the language server must merge it
-* the same way, or the editor reads a different file and reports nothing.
-*/
-function mergeRunnerConfigs(setupRunner, configRunner) {
-	const runner = {
-		...setupRunner ?? {},
-		...configRunner ?? {},
-		cache: mergeCacheConfig(setupRunner?.cache, configRunner?.cache),
-		ruleConcurrency: configRunner?.ruleConcurrency ?? setupRunner?.ruleConcurrency,
-		stats: mergeStatsConfig(setupRunner?.stats, configRunner?.stats),
-		timeoutMs: configRunner?.timeoutMs ?? setupRunner?.timeoutMs
+//#region src/cli/commands/integrations/stop-gate/stop-gate.ts
+const stopGate = defineCommand({
+	action: (context, options) => runStopGateCommand(options, context.io),
+	description: "Run the repository Stop Gate integration",
+	exactArguments: true,
+	name: "stop-gate",
+	options: [{
+		description: "Codex session id",
+		flags: "--session-id <id>"
+	}]
+});
+async function runStopGateCommand(options, io) {
+	if (!options.sessionId) {
+		io.stderr.write("Stop Gate requires --session-id.\n");
+		return 2;
+	}
+	try {
+		const cwd = await findGitRoot(io.cwd);
+		const loaded = await loadAlintConfigWithMetadata(cwd);
+		if (loaded.configFile === void 0) {
+			writeEnvelope((chunk) => io.stdout.write(chunk), {
+				errorCount: 0,
+				schemaVersion: 2,
+				status: "inactive",
+				warningCount: 0
+			});
+			return 0;
+		}
+		const stopGate = resolveStopGateConfig(loaded.config, cwd);
+		if (!stopGate.enabled) {
+			await removeStopGateReport(options.sessionId);
+			writeEnvelope((chunk) => io.stdout.write(chunk), {
+				errorCount: 0,
+				schemaVersion: 2,
+				status: "inactive",
+				warningCount: 0
+			});
+			return 0;
+		}
+		const lint = await runStopGateLint({
+			config: loaded.config,
+			cwd,
+			io,
+			stopGate
+		});
+		if (lint === void 0) {
+			await removeStopGateReport(options.sessionId);
+			writeEnvelope((chunk) => io.stdout.write(chunk), {
+				errorCount: 0,
+				schemaVersion: 2,
+				status: "no-dirty-files",
+				warningCount: 0
+			});
+			return 0;
+		}
+		if (lint.error !== void 0) {
+			const reportPath = await writeStopGateReport(options.sessionId, {
+				cwd,
+				diagnostics: lint.result.diagnostics,
+				execution: lint.result.execution,
+				failure: {
+					details: lint.error.failures,
+					message: lint.error.message
+				},
+				files: lint.files,
+				schemaVersion: 1,
+				target: stopGate.target,
+				usage: lint.result.usage
+			});
+			writeEnvelope((chunk) => io.stdout.write(chunk), {
+				errorCount: 0,
+				message: lint.error.message,
+				reportPath,
+				schemaVersion: 2,
+				status: "runtime-error",
+				warningCount: 0
+			});
+			return 1;
+		}
+		const errorCount = lint.result.diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+		const warningCount = lint.result.diagnostics.length - errorCount;
+		if (errorCount === 0 && warningCount === 0) {
+			await removeStopGateReport(options.sessionId);
+			writeEnvelope((chunk) => io.stdout.write(chunk), {
+				errorCount,
+				schemaVersion: 2,
+				status: "clean",
+				warningCount
+			});
+			return 0;
+		}
+		const reportPath = await writeStopGateReport(options.sessionId, {
+			cwd,
+			diagnostics: lint.result.diagnostics,
+			execution: lint.result.execution,
+			files: lint.files,
+			schemaVersion: 1,
+			target: stopGate.target,
+			usage: lint.result.usage
+		});
+		writeEnvelope((chunk) => io.stdout.write(chunk), {
+			errorCount,
+			findingsHash: fingerprintDiagnostics(lint.result.diagnostics),
+			reportPath,
+			schemaVersion: 2,
+			status: errorCount > 0 ? "errors" : "warnings",
+			warningCount
+		});
+		return 0;
+	} catch (error) {
+		writeEnvelope((chunk) => io.stdout.write(chunk), {
+			errorCount: 0,
+			message: error instanceof StopGateReportTooLargeError ? error.message : error instanceof AlintRunCancelledError ? "Stop Gate timed out before lint completed." : errorMessageFrom(error) ?? "unknown error",
+			schemaVersion: 2,
+			status: "runtime-error",
+			warningCount: 0
+		});
+		return 1;
+	}
+}
+//#endregion
+//#region src/cli/commands/integrations/integrations.ts
+const integrations = defineCommand({
+	children: [stopGate],
+	description: "Run external integrations",
+	name: "integrations"
+});
+//#endregion
+//#region src/cli/reporters/json.ts
+function formatJson(result) {
+	return `${JSON.stringify(result, null, 2)}\n`;
+}
+//#endregion
+//#region src/cli/reporters/stylish.ts
+const colors$3 = createColors({ force: true });
+function formatStylish(input, options = {}) {
+	const diagnostics = Array.isArray(input) ? input : input.diagnostics;
+	const result = Array.isArray(input) ? void 0 : input;
+	const style = createStyle(options.color === true);
+	if (diagnostics.length === 0) return result?.execution?.cached ? `${formatSummary(diagnostics, result, style)}\n` : "";
+	const diagnosticsByFile = /* @__PURE__ */ new Map();
+	for (const diagnostic of diagnostics) {
+		const fileDiagnostics = diagnosticsByFile.get(diagnostic.filePath);
+		if (fileDiagnostics) {
+			fileDiagnostics.push(diagnostic);
+			continue;
+		}
+		diagnosticsByFile.set(diagnostic.filePath, [diagnostic]);
+	}
+	const lines = [];
+	for (const [filePath, fileDiagnostics] of diagnosticsByFile) {
+		lines.push(style.file(filePath));
+		for (const diagnostic of fileDiagnostics) {
+			const line = diagnostic.loc?.start.line ?? 0;
+			const column = diagnostic.loc?.start.column ?? 0;
+			const severity = diagnostic.severity === "warn" ? style.warning("warning") : style.error("error");
+			lines.push(`  ${style.location(`${line}:${column}`)}  ${severity}  ${diagnostic.message}  ${style.ruleId(diagnostic.ruleId)}`);
+		}
+		lines.push("");
+	}
+	lines.push("", formatSummary(diagnostics, result, style));
+	return `${lines.join("\n")}\n`;
+}
+function countCachedDiagnostics(diagnostics, severity) {
+	return diagnostics.filter((diagnostic) => diagnostic.severity === severity && diagnostic.cached === true).length;
+}
+function countDiagnostics$1(diagnostics, severity) {
+	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
+}
+function createStyle(color) {
+	if (!color) return {
+		error: identity,
+		file: identity,
+		location: identity,
+		ruleId: identity,
+		summaryToken: identity,
+		warning: identity
+	};
+	return {
+		error: colors$3.red,
+		file: colors$3.underline,
+		location: colors$3.dim,
+		ruleId: colors$3.dim,
+		summaryToken: colors$3.cyan,
+		warning: colors$3.yellow
 	};
-	return Object.values(runner).some((value) => value !== void 0) ? runner : void 0;
 }
-/** The last `runner` block in the flattened config wins, key by key. */
-function resolveConfigRunner(config) {
-	return normalizeConfig(config).reduce((merged, item) => item.runner ? {
-		...merged,
-		...item.runner
-	} : merged, void 0);
+function formatDiagnosticCount(total, cached, label) {
+	return `${total} ${label}${cached > 0 ? ` (${cached} cached)` : ""}`;
 }
-function mergeCacheConfig(setupCache, configCache) {
-	if (configCache === void 0) return setupCache;
-	if (typeof configCache === "boolean") return configCache;
-	if (typeof setupCache === "object") return {
-		...setupCache,
-		...configCache
+function formatExecutionSummary(execution) {
+	if (!execution || execution.cached === 0) return;
+	return `${execution.cached}/${execution.planned} cached`;
+}
+function formatSummary(diagnostics, result, style) {
+	const warnCount = countDiagnostics$1(diagnostics, "warn");
+	const errorCount = countDiagnostics$1(diagnostics, "error");
+	const cachedWarnCount = countCachedDiagnostics(diagnostics, "warn");
+	const cachedErrorCount = countCachedDiagnostics(diagnostics, "error");
+	const tokens = result === void 0 ? void 0 : formatTokenSummary(result);
+	const problemSummary = [style.warning(formatDiagnosticCount(warnCount, cachedWarnCount, "warn")), style.error(formatDiagnosticCount(errorCount, cachedErrorCount, "error"))].join(" / ");
+	if (tokens === void 0) return problemSummary;
+	const execution = formatExecutionSummary(result?.execution);
+	return [
+		problemSummary,
+		style.summaryToken(tokens),
+		execution
+	].filter((segment) => segment !== void 0).join(" | ");
+}
+function formatTokenSummary(result) {
+	const liveTokens = result.usage.totalTokens.toLocaleString("en-US");
+	const cachedTokens = result.usage.cached?.totalTokens ?? 0;
+	return `${liveTokens} tokens${cachedTokens > 0 ? ` (${cachedTokens.toLocaleString("en-US")} cached)` : ""}`;
+}
+function identity(value) {
+	return value;
+}
+//#endregion
+//#region src/cli/reporters/index.ts
+function formatDiagnostics(format, result, options = {}) {
+	if (format === "json") return formatJson(result);
+	if (format === "stylish") return formatStylish(result, { color: options.color });
+	throw new Error(`Unknown reporter "${format}".`);
+}
+//#endregion
+//#region src/cli/reporters/progress/plain.ts
+function createPlainProgressReporter(options) {
+	const writeLine = (line) => options.write(`${line}\n`);
+	return {
+		onJobRetry: () => {},
+		onJobStart: (payload) => {
+			const target = payload.job.target.name ? `${payload.job.target.kind} ${payload.job.target.name}` : payload.job.target.kind;
+			writeLine(`scan ${payload.job.inputPath} > ${target} > ${payload.job.ruleId}`);
+		},
+		onPrepareEnd: ({ filesTotal }) => writeLine(`alint prepared: ${filesTotal} files`),
+		onPrepareStart: () => writeLine("alint preparing"),
+		onRunEnd: (payload) => {
+			const warnCount = countDiagnostics(payload.diagnostics, "warn");
+			const errorCount = countDiagnostics(payload.diagnostics, "error");
+			const state = payload.execution.failed > 0 ? "failed" : "finished";
+			const { cached, cancelled, completed, failed, skipped } = payload.execution;
+			writeLine(`alint ${state}: ${warnCount} warn, ${errorCount} error, ${payload.usage.totalTokens} tokens, ${completed} completed, ${cached} cached, ${failed} failed, ${cancelled} cancelled, ${skipped} skipped`);
+		}
 	};
-	return configCache;
 }
-function mergeStatsConfig(setupStats, configStats) {
-	if (configStats === void 0) return setupStats;
-	if (typeof configStats === "boolean") return configStats;
-	if (typeof setupStats === "object") return {
-		...setupStats,
-		...configStats
-	};
-	return configStats;
+function countDiagnostics(diagnostics, severity) {
+	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
 }
 //#endregion
-//#region src/cli/runtime/session.ts
-/**
-* Loads config, setup config, and model adapters once, then runs any number of times.
-*
-* The lint command and the language server both use this function. A second implementation would
-* resolve config or cwd differently, and the editor would then read a different cache file.
-*/
-async function createRunSession(io, options = {}) {
-	const [{ defaultModel, setupConfig: fileSetupConfig }, config] = await Promise.all([loadRunSetupConfig(io), loadAlintConfig(io.cwd, options.configPath)]);
-	const runtime = await (options.startModelAdapters ?? startModelAdapters)(fileSetupConfig, io);
-	const { setupConfig } = runtime;
-	let shutdown;
+//#region src/cli/reporters/progress/summary.ts
+const colors$2 = createColors({ force: true });
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function createSummaryProgressReporter(options) {
+	const now = Date.now;
+	const state = createInitialState();
 	return {
-		config,
-		cwd: io.cwd,
-		defaultModel,
-		run: async (runOptions) => {
-			const targets = await findLintTargets({
-				config,
-				cwd: io.cwd,
-				errorOnUnmatchedPattern: true,
-				globInputPaths: true,
-				inputs: runOptions.files ?? []
+		getRows: () => createRows(state, options, now()),
+		onDiagnostic: ({ diagnostic, progress }) => {
+			updateProgress(state, progress);
+			if (diagnostic.severity === "warn") state.warnCount += 1;
+			else state.errorCount += 1;
+		},
+		onExecuteEnd: ({ progress }) => {
+			updateProgress(state, progress);
+		},
+		onExecuteStart: ({ progress, startedAt }) => {
+			updateProgress(state, progress);
+			state.runStartedAt = startedAt ?? state.runStartedAt ?? now();
+		},
+		onFileReady: ({ progress }) => updateProgress(state, progress),
+		onJobEnd: (payload) => {
+			updateProgress(state, payload.progress);
+			const current = state.activeJobs.get(payload.job.id);
+			const group = state.ruleGroups.get(payload.job.ruleId);
+			if (!group) throw new Error(`Cannot finish unqueued progress job "${payload.job.id}".`);
+			group[payload.state] += 1;
+			if (payload.endedAt !== void 0 && current?.startedAt !== void 0 && payload.state !== "cached") group.terminalDurationMs += Math.max(payload.endedAt - current.startedAt, 0);
+			if (payload.state === "cached") {
+				const cachedTokens = state.jobTokens.get(payload.job.id) ?? 0;
+				state.totalTokens = Math.max(state.totalTokens - cachedTokens, 0);
+				state.cachedTokens += cachedTokens;
+			}
+			state.activeJobs.delete(payload.job.id);
+			state.jobTokens.delete(payload.job.id);
+		},
+		onJobQueued: ({ job, progress }) => {
+			updateProgress(state, progress);
+			const group = state.ruleGroups.get(job.ruleId) ?? createRuleGroup(job);
+			group.planned += 1;
+			state.ruleGroups.set(job.ruleId, group);
+			state.activeJobs.set(job.id, {
+				job,
+				state: "queued"
 			});
-			return runAlint({
-				cacheOnly: runOptions.cacheOnly,
-				config,
-				cwd: io.cwd,
-				defaultModel,
-				directories: targets.directories,
-				files: targets.files,
-				modelOverride: runOptions.modelOverride,
-				outputLanguage: runOptions.outputLanguage,
-				progress: runOptions.progress,
-				projectTargets: runOptions.projectTargets,
-				runner: runOptions.runner,
-				setupConfig,
-				signal: runOptions.signal
+		},
+		onJobRetry: (payload) => {
+			updateProgress(state, payload.progress);
+			const current = state.activeJobs.get(payload.job.id);
+			state.activeJobs.set(payload.job.id, {
+				job: payload.job,
+				retry: {
+					attempt: payload.attempt,
+					maxAttempts: payload.maxAttempts,
+					startedAt: payload.startedAt
+				},
+				startedAt: current?.startedAt ?? payload.startedAt ?? now(),
+				state: current?.state ?? "running"
 			});
 		},
-		runner: mergeRunnerConfigs(setupConfig.runner, resolveConfigRunner(config)),
-		setupConfig,
-		shutdown: () => shutdown ??= runtime.shutdown()
-	};
-}
-//#endregion
-//#region src/cli/commands/lint/errors.ts
-const colors$1 = createColors({ force: true });
-function formatCancelledError(error, color) {
-	return `${color ? colors$1.red("error") : "error"} ${error.message}\n`;
-}
-function formatRunError(error, color) {
-	const label = color ? colors$1.red("error") : "error";
-	const fileFailures = error.failures.filter((failure) => "file" in failure);
-	const groups = groupFailuresByRule(error.failures.filter((failure) => "job" in failure));
-	return [
-		`${label} ${error.message}`,
-		"",
-		...fileFailures.length > 0 ? [
-			`Failed Files ${fileFailures.length}`,
-			"",
-			...formatFileFailures(fileFailures, color)
-		] : [],
-		...groups.length > 0 ? [
-			`Failed Rules ${groups.length}`,
-			"",
-			...formatFailureGroups(groups, color)
-		] : []
-	].join("\n");
-}
-function formatFailureGroups(groups, color) {
-	const lines = [];
-	for (const [ruleId, group] of groups) {
-		const failLabel = color ? colors$1.bgRed(colors$1.bold(" FAIL ")) : "FAIL";
-		const targetLabel = group.length === 1 ? "target" : "targets";
-		lines.push(`${failLabel} ${ruleId} ${group.length} ${targetLabel}`);
-		for (const failure of group) {
-			lines.push(`  ${formatTarget(failure)}`);
-			lines.push(`    [${failure.kind}] ${failure.message}`);
-			for (const cause of failure.causes) {
-				const code = cause.code === void 0 ? "" : `[${cause.code}] `;
-				lines.push(`      Caused by: ${code}${cause.message}`);
+		onJobStart: (payload) => {
+			updateProgress(state, payload.progress);
+			state.activeJobs.set(payload.job.id, {
+				job: payload.job,
+				startedAt: payload.startedAt ?? now(),
+				state: "running"
+			});
+		},
+		onPlanningEnd: ({ progress }) => updateProgress(state, progress),
+		onPrepareStart: ({ startedAt }) => {
+			state.activeJobs.clear();
+			state.errorCount = 0;
+			state.execution = createCounts();
+			state.progress = createProgress();
+			state.ruleGroups.clear();
+			state.runStartedAt = startedAt ?? now();
+			state.animationTick = 0;
+			state.cachedTokens = 0;
+			state.jobTokens.clear();
+			state.totalTokens = 0;
+			state.warnCount = 0;
+		},
+		onRunEnd: (payload) => {
+			state.warnCount = payload.diagnostics.filter((diagnostic) => diagnostic.severity === "warn").length;
+			state.errorCount = payload.diagnostics.length - state.warnCount;
+			updateProgress(state, payload.progress);
+			state.totalTokens = payload.usage.totalTokens;
+			state.cachedTokens = payload.usage.cached?.totalTokens ?? 0;
+			state.runStartedAt = payload.startedAt ?? state.runStartedAt;
+		},
+		onUsage: ({ job, progress, record }) => {
+			updateProgress(state, progress);
+			if (record.totalTokens != null && Number.isFinite(record.totalTokens)) {
+				state.jobTokens.set(job.id, (state.jobTokens.get(job.id) ?? 0) + record.totalTokens);
+				state.totalTokens += record.totalTokens;
 			}
+		},
+		/**
+		* Advances the summary animation on each renderer interval.
+		*
+		* Triggering workflow:
+		*
+		* `createTtyProgressRenderer`
+		*   -> `createCliProgressReporter` `createInterval` callback
+		*     -> `SummaryProgressReporter.tick` (this handler)
+		*
+		* Upstream:
+		* - `createCliProgressReporter` `createInterval` callback registered by `createTtyProgressRenderer`
+		*
+		* Downstream:
+		* - Increments `state.animationTick`, consumed by {@link createRows}, {@link formatSpinnerFrame}, and {@link formatMiniBarSegment}.
+		*/
+		tick: () => {
+			state.animationTick += 1;
 		}
-		lines.push("");
-	}
-	return lines;
-}
-function formatFileFailures(failures, color) {
-	const lines = [];
-	for (const failure of failures) {
-		const failLabel = color ? colors$1.bgRed(colors$1.bold(" FAIL ")) : "FAIL";
-		lines.push(`${failLabel} ${failure.file.path}`);
-		lines.push(`  [${failure.kind}] ${failure.message}`);
-		lines.push("");
-	}
-	return lines;
-}
-function formatTarget(failure) {
-	const target = failure.job.target.name ? `${failure.job.target.kind} ${failure.job.target.name}` : failure.job.target.kind;
-	return `${failure.job.inputPath} > ${target}`;
-}
-function groupFailuresByRule(failures) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const failure of failures) {
-		const group = groups.get(failure.job.ruleId) ?? [];
-		group.push(failure);
-		groups.set(failure.job.ruleId, group);
-	}
-	return [...groups];
-}
-//#endregion
-//#region src/cli/commands/lint/runner.ts
-/**
-* Applies this invocation's flags on top of the project's resolved runner.
-*
-* The setup/config merge itself lives in `runtime/runner.ts` because the language server needs the
-* same base without any flags; only the overrides below are CLI-shaped.
-*/
-function resolveRunnerConfig(baseRunner, options) {
-	const ruleConcurrency = parsePositiveIntegerOption(options.ruleConcurrency, "--rule-concurrency");
-	const timeoutMs = parsePositiveIntegerOption(options.timeoutMs, "--timeout-ms");
-	const runner = {
-		...baseRunner ?? {},
-		cache: resolveCacheOption(baseRunner?.cache, options),
-		ruleConcurrency: ruleConcurrency ?? baseRunner?.ruleConcurrency,
-		stats: options.stats === false ? false : baseRunner?.stats,
-		timeoutMs: timeoutMs ?? baseRunner?.timeoutMs
 	};
-	return Object.values(runner).some((value) => value !== void 0) ? runner : void 0;
-}
-function parsePositiveIntegerOption(value, label) {
-	if (value === void 0) return;
-	const parsed = Number(value);
-	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${label} must be a positive integer.`);
-	return parsed;
 }
-function resolveCacheOption(baseCache, options) {
-	if (options.cache === false) return false;
-	if (options.cacheLocation !== void 0) return typeof baseCache === "object" ? {
-		...baseCache,
-		location: options.cacheLocation
-	} : { location: options.cacheLocation };
-	return baseCache;
+function compareRuleGroups(left, right) {
+	const leftActive = left.jobs.some((job) => job.state === "running") ? 1 : 0;
+	const rightActive = right.jobs.some((job) => job.state === "running") ? 1 : 0;
+	if (leftActive !== rightActive) return rightActive - leftActive;
+	if (left.failed !== right.failed) return right.failed - left.failed;
+	return left.firstJobIndex - right.firstJobIndex;
 }
-//#endregion
-//#region src/cli/stats/ci.ts
-function isCi(env = process.env) {
-	const ci = env.CI;
-	if (ci !== void 0 && ci !== "" && ci !== "0" && ci !== "false") return true;
-	return Boolean(env.GITHUB_ACTIONS || env.GITLAB_CI || env.CIRCLECI || env.BUILDKITE || env.TF_BUILD);
+function compareRunningJobs(left, right) {
+	const leftStartedAt = left.startedAt ?? Number.POSITIVE_INFINITY;
+	const rightStartedAt = right.startedAt ?? Number.POSITIVE_INFINITY;
+	if (leftStartedAt !== rightStartedAt) return leftStartedAt - rightStartedAt;
+	return left.job.index - right.job.index;
 }
-//#endregion
-//#region src/cli/stats/since.ts
-/**
-* Parse a `--since` time into an inclusive lower-bound timestamp.
-*
-* Supported formats:
-* - `Nh`/`Nd`/`Nw`/`Nm`/`Ny` — now minus N hours/days/weeks/months/years.
-*   Weeks, months, and years are fixed approximations (7/30/365 days). `m` is
-*   months here, not minutes — a day is the finest window this tool tracks.
-* - `YYYY-MM`/`YYYY-MM-DD` — start of that UTC month/day.
-*
-* Edge cases:
-* - An empty time means "no lower bound".
-* - An unrecognized time throws.
-*/
-const HOUR_MS = 36e5;
-const UNIT_MS = {
-	d: 24 * HOUR_MS,
-	h: HOUR_MS,
-	m: 720 * HOUR_MS,
-	w: 168 * HOUR_MS,
-	y: 8760 * HOUR_MS
-};
-function parseSince(time, now) {
-	if (time === void 0 || time === "") return;
-	const relative = /^(\d+)([dhmwy])$/u.exec(time);
-	if (relative) return now - Number(relative[1]) * UNIT_MS[relative[2]];
-	const calendar = /^(\d{4})-(\d{2})(?:-(\d{2}))?$/u.exec(time);
-	if (calendar) {
-		const year = Number(calendar[1]);
-		const month = Number(calendar[2]);
-		const day = calendar[3] === void 0 ? 1 : Number(calendar[3]);
-		return Date.UTC(year, month - 1, day);
+function completeGraphemeBoundary(input, maximumIndex) {
+	let boundary = 0;
+	for (const segment of graphemeSegmenter.segment(input)) {
+		const end = segment.index + segment.segment.length;
+		if (end > maximumIndex) break;
+		boundary = end;
 	}
-	throw new Error(`Invalid --since "${time}": use e.g. 24h, 7d, 2w, 3m, 1y, 2025-01, or 2025-01-15.`);
+	return boundary;
 }
-//#endregion
-//#region src/cli/stats/jsonl.ts
-const DEFAULT_RETENTION_MONTHS = 12;
-const STATS_FILE_PATTERN = /^stats-(\d{4})-(\d{2})\.jsonl$/u;
-const DAY_MS = 864e5;
-const MONTH_LABELS$1 = [
-	"Jan",
-	"Feb",
-	"Mar",
-	"Apr",
-	"May",
-	"Jun",
-	"Jul",
-	"Aug",
-	"Sep",
-	"Oct",
-	"Nov",
-	"Dec"
-];
-function createJsonlStatsStore(options) {
-	const retentionMonths = options.retentionMonths ?? DEFAULT_RETENTION_MONTHS;
+function createCounts(planned = 0) {
 	return {
-		query: (filter) => query(options.dir, filter ?? {}, Date.now),
-		querySeries: (filter) => querySeries(options.dir, filter ?? {}, Date.now),
-		record: (input) => record(options.dir, input, Date.now(), retentionMonths)
+		cached: 0,
+		cancelled: 0,
+		completed: 0,
+		failed: 0,
+		planned,
+		queued: 0,
+		running: 0,
+		skipped: 0
 	};
 }
-function accumulate(rows, key, inTok, outTok, totalTok, countRun) {
-	const row = rows.get(key) ?? {
-		inTok: 0,
-		key,
-		outTok: 0,
-		runs: 0,
-		totalTok: 0
+function createInitialState() {
+	return {
+		activeJobs: /* @__PURE__ */ new Map(),
+		animationTick: 0,
+		cachedTokens: 0,
+		errorCount: 0,
+		execution: createCounts(),
+		jobTokens: /* @__PURE__ */ new Map(),
+		progress: createProgress(),
+		ruleGroups: /* @__PURE__ */ new Map(),
+		totalTokens: 0,
+		warnCount: 0
 	};
-	row.inTok += inTok;
-	row.outTok += outTok;
-	row.totalTok += totalTok;
-	if (countRun) row.runs += 1;
-	rows.set(key, row);
-	return row;
-}
-function bucketLabel(startMs, interval) {
-	const date = new Date(startMs);
-	if (interval === "month") return MONTH_LABELS$1[date.getUTCMonth()];
-	return `${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}`;
-}
-function bucketStart(ts, interval) {
-	const date = new Date(ts);
-	if (interval === "month") return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1);
-	const dayStart = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
-	if (interval === "week") return dayStart - (new Date(dayStart).getUTCDay() + 6) % 7 * DAY_MS;
-	return dayStart;
-}
-function chooseInterval(since, nowMs, timestamps) {
-	if (since !== void 0) return intervalForDuration(nowMs - since);
-	if (timestamps.length < 2) return "day";
-	return intervalForDuration(Math.max(...timestamps) - Math.min(...timestamps));
-}
-function fillBuckets(buckets, interval) {
-	if (buckets.size === 0) return [];
-	const starts = [...buckets.keys()].sort((left, right) => left - right);
-	const last = starts.at(-1);
-	const filled = [];
-	for (let startMs = starts[0]; startMs <= last; startMs = nextBucketStart(startMs, interval)) filled.push(buckets.get(startMs) ?? {
-		inTok: 0,
-		key: bucketLabel(startMs, interval),
-		outTok: 0,
-		runs: 0,
-		startMs,
-		totalTok: 0
-	});
-	return filled;
-}
-function intervalForDuration(ms) {
-	const days = ms / DAY_MS;
-	if (days <= 21) return "day";
-	if (days <= 120) return "week";
-	return "month";
-}
-function isEnoent(error) {
-	return error instanceof Error && error.code === "ENOENT";
-}
-function monthIndexOf(ts) {
-	const date = new Date(ts);
-	return date.getUTCFullYear() * 12 + date.getUTCMonth();
-}
-function nextBucketStart(startMs, interval) {
-	if (interval === "month") {
-		const date = new Date(startMs);
-		return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1);
-	}
-	return startMs + (interval === "week" ? 7 * DAY_MS : DAY_MS);
 }
-function parseRunLine(line) {
-	try {
-		const value = JSON.parse(line);
-		if (typeof value.ts === "number" && typeof value.cwd === "string" && value.usage != null) return value;
-		return;
-	} catch {
-		return;
-	}
+function createProgress() {
+	return {
+		execution: createCounts(),
+		filesPlanned: 0,
+		filesTotal: 0,
+		jobsCompleted: 0,
+		jobsStarted: 0,
+		jobsTotal: 0,
+		planningComplete: false
+	};
 }
-async function prune(dir, ts, retentionMonths) {
-	if (retentionMonths <= 0) return;
-	const cutoff = monthIndexOf(ts) - (retentionMonths - 1);
-	const files = await statsFiles(dir);
-	for (const { month, name } of files) if (month < cutoff) await rm(join(dir, name));
+function createRows(state, options, now) {
+	if (options.rows !== void 0 && options.rows <= 0) return [];
+	const groups = createRuleGroups(state);
+	const footerRows = options.rows === void 0 ? 3 : Math.min(options.rows, 3);
+	const separatorRows = options.rows === void 0 || options.rows - footerRows > 1 ? 1 : 0;
+	const visible = formatContentRows(groups, state, options, now, options.rows === void 0 ? Number.POSITIVE_INFINITY : Math.max(options.rows - footerRows - separatorRows, 0));
+	const footer = formatFooters(state, options, now);
+	const actualSeparatorRows = visible.length > 0 ? separatorRows : 0;
+	const visibleFooters = options.rows === void 0 ? footer : footer.slice(0, Math.max(options.rows - visible.length - actualSeparatorRows, 0));
+	if (actualSeparatorRows === 1) visible.push("");
+	visible.push(...visibleFooters);
+	return options.color ? visible.map((row) => styleRow(row, state, state.warnCount, state.errorCount, options)) : visible;
 }
-async function query(dir, filter, now) {
-	const dimension = filter.by ?? "model";
-	const since = parseSince(filter.since, now());
-	const rules = ruleSet(filter.rules);
-	const runs = await readRuns(dir);
-	const rows = /* @__PURE__ */ new Map();
-	let totalRuns = 0;
-	let totalIn = 0;
-	let totalOut = 0;
-	let totalTok = 0;
-	for (const run of runs) {
-		if (!runInWindow(run, since, filter.cwd)) continue;
-		const slice = sliceRun(run, rules);
-		if (!slice.touched) continue;
-		totalRuns += 1;
-		totalIn += slice.inTok;
-		totalOut += slice.outTok;
-		totalTok += slice.totalTok;
-		if (dimension === "dir") {
-			accumulate(rows, run.cwd, slice.inTok, slice.outTok, slice.totalTok, true);
-			continue;
-		}
-		const seenKeys = /* @__PURE__ */ new Set();
-		for (const usageRecord of slice.usageRecords) {
-			const key = recordKey(usageRecord, dimension);
-			accumulate(rows, key, usageRecord.inTok, usageRecord.outTok, usageRecord.totalTok, !seenKeys.has(key));
-			seenKeys.add(key);
-		}
-	}
+function createRuleGroup(job) {
 	return {
-		dimension,
-		rows: [...rows.values()].sort((left, right) => right.totalTok - left.totalTok),
-		totalIn,
-		totalOut,
-		totalRuns,
-		totalTok
+		cached: 0,
+		cancelled: 0,
+		completed: 0,
+		failed: 0,
+		firstJobIndex: job.index,
+		planned: 0,
+		ruleId: job.ruleId,
+		skipped: 0,
+		terminalDurationMs: 0
 	};
 }
-async function querySeries(dir, filter, now) {
-	const nowMs = now();
-	const since = parseSince(filter.since, nowMs);
-	const rules = ruleSet(filter.rules);
-	const runs = await readRuns(dir);
-	const sliced = [];
-	for (const run of runs) {
-		if (!runInWindow(run, since, filter.cwd)) continue;
-		const slice = sliceRun(run, rules);
-		if (slice.touched) sliced.push({
-			slice,
-			ts: run.ts
+function createRuleGroups(state) {
+	const groups = new Map([...state.ruleGroups].map(([ruleId, group]) => [ruleId, {
+		...group,
+		jobs: []
+	}]));
+	for (const job of state.activeJobs.values()) groups.get(job.job.ruleId)?.jobs.push(job);
+	return [...groups.values()].sort(compareRuleGroups);
+}
+function estimateEta(durationMs, terminal, planned) {
+	if (terminal <= 0 || planned <= 0 || durationMs <= 0) return "eta ?";
+	return `eta ~${formatDuration$1(durationMs * (planned - terminal) / terminal)}`;
+}
+function fitRow(row, columns) {
+	if (columns <= 0) return "";
+	if (fastStringWidth(row) <= columns) return row;
+	let limit = columns;
+	while (limit > 0) {
+		const result = fastStringTruncatedWidth(row, {
+			ellipsis: "…",
+			limit
 		});
+		const index = completeGraphemeBoundary(row, result.index);
+		const visible = row.slice(0, index);
+		const fitted = `${visible}${visible.includes("\x1B") ? "\x1B[0m" : ""}${result.ellipsed ? "…" : ""}`;
+		const overflow = fastStringWidth(fitted) - columns;
+		if (overflow <= 0) return fitted;
+		limit -= overflow;
 	}
-	const interval = filter.interval ?? chooseInterval(since, nowMs, sliced.map((entry) => entry.ts));
-	const buckets = /* @__PURE__ */ new Map();
-	let totalRuns = 0;
-	let totalIn = 0;
-	let totalOut = 0;
-	let totalTok = 0;
-	for (const { slice, ts } of sliced) {
-		const startMs = bucketStart(ts, interval);
-		const bucket = buckets.get(startMs) ?? {
-			inTok: 0,
-			key: bucketLabel(startMs, interval),
-			outTok: 0,
-			runs: 0,
-			startMs,
-			totalTok: 0
-		};
-		bucket.runs += 1;
-		bucket.inTok += slice.inTok;
-		bucket.outTok += slice.outTok;
-		bucket.totalTok += slice.totalTok;
-		buckets.set(startMs, bucket);
-		totalRuns += 1;
-		totalIn += slice.inTok;
-		totalOut += slice.outTok;
-		totalTok += slice.totalTok;
-	}
-	return {
-		buckets: fillBuckets(buckets, interval),
-		interval,
-		totalIn,
-		totalOut,
-		totalRuns,
-		totalTok
-	};
+	return "";
 }
-async function readRuns(dir) {
-	const files = await statsFiles(dir);
-	const runs = [];
-	for (const { name } of files) {
-		const content = await readFile(join(dir, name), "utf8");
-		for (const line of content.split("\n")) {
-			if (line.trim() === "") continue;
-			const run = parseRunLine(line);
-			if (run) runs.push(run);
+function formatCollapsedRunningRow(hidden, options) {
+	return fitRow(`   └─ ${hidden} more running`, options.columns);
+}
+function formatContentRows(groups, state, options, now, contentBudget) {
+	const rows = [];
+	const renderableGroups = groups.filter((group) => group.jobs.some((job) => job.state === "running") || group.failed > 0);
+	const runningCount = renderableGroups.reduce((sum, group) => sum + group.jobs.filter((job) => job.state === "running").length, 0);
+	if (contentBudget === 1) {
+		const failedGroup = renderableGroups.find((group) => group.failed > 0);
+		if (failedGroup) return [formatRuleRow(failedGroup, state, options)];
+		if (runningCount > 0) return [formatCollapsedRunningRow(runningCount, options)];
+	}
+	for (const [groupIndex, group] of renderableGroups.entries()) {
+		if (rows.length >= contentBudget) break;
+		const groupStart = rows.length;
+		rows.push(formatRuleRow(group, state, options));
+		const runningJobs = group.jobs.filter((job) => job.state === "running").sort(compareRunningJobs);
+		const remainingGroups = renderableGroups.length - groupIndex - 1;
+		for (const [index, job] of runningJobs.entries()) {
+			const rowsReservedForLaterGroups = Math.min(remainingGroups, Math.max(contentBudget - rows.length, 0));
+			if (rows.length >= contentBudget) {
+				const hidden = runningJobs.length - index;
+				if (rows.length > groupStart + 1 && hidden > 0) rows[rows.length - 1] = formatCollapsedRunningRow(hidden, options);
+				break;
+			}
+			if (rows.length + 1 + rowsReservedForLaterGroups >= contentBudget) {
+				if (runningJobs.length > 1) rows.push(formatCollapsedRunningRow(runningJobs.length - index, options));
+				break;
+			}
+			rows.push(formatTargetRow(job, options, now, index === runningJobs.length - 1));
 		}
 	}
-	return runs;
+	return rows;
 }
-async function record(dir, input, ts, retentionMonths) {
-	const stat = {
-		ts,
-		...input
-	};
-	await mkdir(dir, { recursive: true });
-	await appendFile(join(dir, statsFileName(ts)), `${JSON.stringify(stat)}\n`, "utf8");
-	await prune(dir, ts, retentionMonths);
+function formatDuration$1(ms) {
+	const durationMs = Math.max(ms, 0);
+	if (durationMs < 6e4) return `${(durationMs / 1e3).toFixed(1)}s`;
+	return formatDuration(intervalToDuration({
+		end: durationMs,
+		start: 0
+	}));
 }
-function recordKey(record, dimension) {
-	if (dimension === "rule") return record.ruleId;
-	if (dimension === "operation") return record.operation ?? record.ruleId;
-	return `${record.providerId}/${record.modelId}`;
+function formatFooters(state, options, now) {
+	const terminal = terminalCount(state.execution);
+	const elapsed = state.runStartedAt === void 0 ? 0 : now - state.runStartedAt;
+	const progressBar = state.progress.planningComplete ? formatMiniBarSegment(terminal, state.execution.planned, state.animationTick, options) : "";
+	const eta = state.progress.planningComplete ? estimateEta(elapsed, terminal, state.execution.planned) : "eta ?";
+	const projectedTokens = state.progress.planningComplete && terminal > 0 && state.execution.planned > 0 ? Math.ceil((state.totalTokens + state.cachedTokens) * state.execution.planned / terminal) : void 0;
+	const discovering = state.progress.planningComplete ? "" : " jobs (discovering)";
+	return [
+		fitRow(`${terminal}/${state.execution.planned}${discovering}${progressBar} ${formatDuration$1(elapsed)} -> ${eta === "eta ?" ? "~?" : eta.replace("eta ", "")}`, options.columns),
+		fitRow(`${state.execution.running} concurrency / ${state.execution.queued} queued / ${state.execution.cached} cached / ${state.execution.failed} failed`, options.columns),
+		fitRow(`${state.totalTokens.toLocaleString("en-US")} tokens (${state.cachedTokens.toLocaleString("en-US")} cached) -> ${projectedTokens === void 0 ? "~?" : `~${projectedTokens.toLocaleString("en-US")} tokens`}`, options.columns)
+	];
 }
-function ruleSet(rules) {
-	return rules && rules.length > 0 ? new Set(rules) : void 0;
+function formatMiniBarSegment(completed, planned, tick, options) {
+	if (options.columns < 60) return "";
+	return ` ${formatMiniBar({
+		completed,
+		planned,
+		tick,
+		width: 10
+	})}`;
 }
-function runInWindow(run, since, cwd) {
-	return (since === void 0 || run.ts >= since) && (cwd === void 0 || run.cwd === cwd);
+function formatRuleRow(group, state, options) {
+	const spinner = formatSpinnerFrame(state.animationTick, options.spinnerFrames);
+	const terminal = group.completed + group.cached + group.failed + group.cancelled + group.skipped;
+	const percent = group.planned > 0 ? Math.floor(terminal / group.planned * 100) : 0;
+	const bar = formatMiniBarSegment(terminal, group.planned, state.animationTick, options);
+	const running = group.jobs.filter((job) => job.state === "running").length;
+	const failed = group.failed > 0 ? ` ${group.failed} failed` : "";
+	const eta = estimateEta(group.terminalDurationMs, terminal, group.planned);
+	return fitRow(`${spinner} ${group.ruleId} ${terminal}/${group.planned} ${percent}%${bar} ${eta} ${running} running${failed}`, options.columns);
 }
-function sliceRun(run, rules) {
-	if (rules === void 0) return {
-		inTok: run.usage.inTok,
-		outTok: run.usage.outTok,
-		totalTok: run.usage.totalTok,
-		touched: true,
-		usageRecords: run.usage.records
-	};
-	const usageRecords = run.usage.records.filter((record) => rules.has(record.ruleId));
-	return {
-		inTok: sumBy(usageRecords, (record) => record.inTok),
-		outTok: sumBy(usageRecords, (record) => record.outTok),
-		totalTok: sumBy(usageRecords, (record) => record.totalTok),
-		touched: usageRecords.length > 0,
-		usageRecords
-	};
+function formatSpinnerFrame(animationTick, spinnerFrames) {
+	return spinnerFrames[animationTick % Math.max(spinnerFrames.length, 1)] ?? "";
 }
-function statsFileName(ts) {
-	const date = new Date(ts);
-	return `stats-${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}.jsonl`;
+function formatTargetRow(jobState, options, now, last) {
+	const inputPath = options.cwd ? relative$1(options.cwd, jobState.job.inputPath) || "." : jobState.job.inputPath;
+	const target = jobState.job.target.name ? `${jobState.job.target.kind} ${jobState.job.target.name}` : jobState.job.target.kind;
+	const startedAt = jobState.retry?.startedAt ?? jobState.startedAt ?? now;
+	return fitRow(`${last ? "   └─" : "   ├─"} ${inputPath} > ${target} ${jobState.retry ? `${jobState.retry.attempt}/${jobState.retry.maxAttempts} retrying elapsed ${formatDuration$1(now - startedAt)}` : `running ${formatDuration$1(now - startedAt)}`}`, options.columns);
 }
-async function statsFiles(dir) {
-	let entries;
-	try {
-		entries = await readdir(dir);
-	} catch (error) {
-		if (isEnoent(error)) return [];
-		throw error;
-	}
-	return entries.map((name) => {
-		const match = STATS_FILE_PATTERN.exec(name);
-		return match ? {
-			month: Number(match[1]) * 12 + (Number(match[2]) - 1),
-			name
-		} : void 0;
-	}).filter((entry) => entry !== void 0).sort((left, right) => left.month - right.month);
+function styleRow(row, state, warnCount, errorCount, options) {
+	let styledRow = row;
+	const spinner = formatSpinnerFrame(state.animationTick, options.spinnerFrames);
+	if (spinner) styledRow = styledRow.replace(spinner, colors$2.cyan(spinner));
+	return styledRow.replace(`${state.execution.running} concurrency`, colors$2.cyan(`${state.execution.running} concurrency`)).replace(`${state.totalTokens.toLocaleString("en-US")} tokens`, colors$2.cyan(`${state.totalTokens.toLocaleString("en-US")} tokens`)).replace(`(${state.cachedTokens.toLocaleString("en-US")} cached)`, colors$2.dim(`(${state.cachedTokens.toLocaleString("en-US")} cached)`)).replace(` / ${state.execution.cached} cached / `, ` / ${colors$2.dim(`${state.execution.cached} cached`)} / `).replace(`${warnCount} warn`, colors$2.yellow(`${warnCount} warn`)).replace(`${errorCount} error`, (errorCount > 0 ? colors$2.red : colors$2.gray)(`${errorCount} error`)).replace(`${state.execution.failed} failed`, (state.execution.failed > 0 ? colors$2.red : colors$2.gray)(`${state.execution.failed} failed`)).replace(/\[([█▓░]*?)(░+)\]/g, (_, active, pending) => `[${active}${colors$2.gray(pending)}]`).replace(/\//g, colors$2.gray("/"));
 }
-function sumBy(items, select) {
-	let total = 0;
-	for (const item of items) total += select(item);
-	return total;
+function terminalCount(counts) {
+	return counts.completed + counts.failed + counts.cached + counts.skipped + counts.cancelled;
 }
-//#endregion
-//#region src/cli/stats/record.ts
-function createRunStat(input) {
-	return {
-		cwd: input.cwd,
-		durationMs: input.durationMs,
-		ruleCounts: input.ruleCounts,
-		usage: {
-			inTok: input.usage.inputTokens,
-			outTok: input.usage.outputTokens,
-			records: input.usage.records.map(toStatsUsageRecord),
-			totalTok: input.usage.totalTokens
-		}
+function updateProgress(state, progress) {
+	state.execution = { ...progress.execution };
+	state.progress = {
+		...progress,
+		execution: { ...progress.execution }
 	};
 }
-function readOperation(metadata) {
-	if (typeof metadata !== "object" || metadata === null || !("operation" in metadata)) return;
-	const operation = metadata.operation;
-	return typeof operation === "string" ? operation : void 0;
-}
-function toStatsUsageRecord(record) {
-	return {
-		filePath: record.filePath,
-		inTok: record.inputTokens ?? 0,
-		modelId: record.modelId,
-		operation: readOperation(record.metadata),
-		outTok: record.outputTokens ?? 0,
-		providerId: record.providerId,
-		ruleId: record.ruleId,
-		totalTok: record.totalTokens ?? 0
+//#endregion
+//#region src/cli/reporters/progress/tty.ts
+const clearCurrentLine = "\r\x1B[K";
+const clearPreviousLine = "\r\x1B[1A\x1B[K";
+function createTtyProgressRenderer(options) {
+	let interval;
+	let previousRows = 0;
+	const clearPreviousFrame = () => {
+		if (previousRows === 0) return;
+		let sequence = clearCurrentLine;
+		for (let row = 1; row < previousRows; row += 1) sequence += clearPreviousLine;
+		options.write(sequence);
+		previousRows = 0;
+	};
+	const render = () => {
+		clearPreviousFrame();
+		const rows = options.getRows();
+		if (rows.length === 0) return;
+		options.write(rows.join("\n"));
+		previousRows = rows.length;
 	};
-}
-//#endregion
-//#region src/cli/commands/lint/stats.ts
-function createStatsCollector() {
-	const counts = {
-		cached: 0,
-		cancelled: 0,
-		completed: 0,
-		failed: 0,
-		planned: 0
+	const write = (chunk) => {
+		const wasRendering = interval !== void 0;
+		clearPreviousFrame();
+		options.write(chunk);
+		if (wasRendering) render();
 	};
-	let startedAt;
-	let endedAt;
 	return {
-		counts,
-		durationMs: () => startedAt !== void 0 && endedAt !== void 0 ? endedAt - startedAt : void 0,
-		reporter: {
-			onPrepareStart: (payload) => {
-				startedAt = payload.startedAt;
-			},
-			onRunEnd: (payload) => {
-				counts.cached = payload.execution.cached;
-				counts.cancelled = payload.execution.cancelled;
-				counts.completed = payload.execution.completed;
-				counts.failed = payload.execution.failed;
-				counts.planned = payload.execution.planned;
-				endedAt = payload.endedAt;
+		finish: () => {
+			if (interval) {
+				options.clearInterval(interval);
+				interval = void 0;
 			}
-		}
+			clearPreviousFrame();
+		},
+		render,
+		start: () => {
+			if (!interval) {
+				interval = options.createInterval(render, options.intervalMs);
+				if (isUnrefableInterval(interval)) interval.unref();
+			}
+			render();
+		},
+		write
 	};
 }
-function mergeProgressReporters(base, extra) {
-	if (!base) return extra;
-	if (!extra) return base;
-	const baseState = {
-		disabled: false,
-		reporter: base
-	};
-	const extraState = {
-		disabled: false,
-		reporter: extra
-	};
-	let firstFailure;
-	const deliver = (state, callback) => {
-		if (state.disabled) return;
-		try {
-			callback(state.reporter);
-		} catch (error) {
-			state.disabled = true;
-			firstFailure ??= normalizeReporterError(error);
-		}
+function isUnrefableInterval(interval) {
+	if (typeof interval !== "object" || interval === null || !("unref" in interval)) return false;
+	return typeof interval.unref === "function";
+}
+//#endregion
+//#region src/cli/reporters/progress/index.ts
+function createCliProgressReporter(options) {
+	if (!options.isTty) return {
+		dispose: () => {},
+		reporter: createPlainProgressReporter({ write: options.write }),
+		write: options.write
 	};
-	const deliverBoth = (callback) => {
-		deliver(baseState, callback);
-		deliver(extraState, callback);
+	const summary = createSummaryProgressReporter({
+		color: options.color,
+		columns: options.columns,
+		cwd: options.cwd,
+		rows: options.rows,
+		spinnerFrames: cliSpinners.dots.frames
+	});
+	const renderer = createTtyProgressRenderer({
+		clearInterval: (handle) => globalThis.clearInterval(handle),
+		createInterval: (callback, intervalMs) => globalThis.setInterval(() => {
+			summary.tick();
+			callback();
+		}, intervalMs),
+		getRows: summary.getRows,
+		intervalMs: 120,
+		write: options.write
+	});
+	const reporter = createRenderingProgressReporter(summary, renderer);
+	return {
+		dispose: renderer.finish,
+		reporter,
+		write: renderer.write
 	};
+}
+function createRenderingProgressReporter(summary, renderer) {
 	return {
 		onDiagnostic: (payload) => {
-			deliverBoth((reporter) => reporter.onDiagnostic?.(payload));
+			summary.onDiagnostic?.(payload);
+			renderer.render();
 		},
 		onExecuteEnd: (payload) => {
-			deliverBoth((reporter) => reporter.onExecuteEnd?.(payload));
+			summary.onExecuteEnd?.(payload);
+			renderer.render();
 		},
 		onExecuteStart: (payload) => {
-			deliverBoth((reporter) => reporter.onExecuteStart?.(payload));
+			summary.onExecuteStart?.(payload);
+			renderer.render();
 		},
 		onFileReady: (payload) => {
-			deliverBoth((reporter) => reporter.onFileReady?.(payload));
+			summary.onFileReady?.(payload);
+			renderer.render();
 		},
 		onJobEnd: (payload) => {
-			deliverBoth((reporter) => reporter.onJobEnd?.(payload));
+			summary.onJobEnd?.(payload);
+			renderer.render();
 		},
 		onJobQueued: (payload) => {
-			deliverBoth((reporter) => reporter.onJobQueued?.(payload));
+			summary.onJobQueued?.(payload);
+			renderer.render();
 		},
 		onJobRetry: (payload) => {
-			deliverBoth((reporter) => reporter.onJobRetry?.(payload));
+			summary.onJobRetry?.(payload);
+			renderer.render();
 		},
 		onJobStart: (payload) => {
-			deliverBoth((reporter) => reporter.onJobStart?.(payload));
-		},
-		onPlanningEnd: (payload) => {
-			deliverBoth((reporter) => reporter.onPlanningEnd?.(payload));
+			summary.onJobStart?.(payload);
+			renderer.render();
 		},
 		onPrepareEnd: (payload) => {
-			deliverBoth((reporter) => reporter.onPrepareEnd?.(payload));
+			summary.onPrepareEnd?.(payload);
+			renderer.render();
 		},
 		onPrepareStart: (payload) => {
-			deliverBoth((reporter) => reporter.onPrepareStart?.(payload));
+			summary.onPrepareStart?.(payload);
+			renderer.start();
 		},
 		onRunEnd: (payload) => {
-			deliverBoth((reporter) => reporter.onRunEnd?.(payload));
-			if (firstFailure) throw firstFailure;
+			summary.onRunEnd?.(payload);
+			renderer.render();
 		},
 		onUsage: (payload) => {
-			deliverBoth((reporter) => reporter.onUsage?.(payload));
+			summary.onUsage?.(payload);
+			renderer.render();
 		}
 	};
 }
-function resolveStatsWrite(stats, env) {
-	if (isCi(env)) return;
-	if (!(stats === false ? false : stats === void 0 || stats === true ? true : stats.enabled !== false)) return;
-	const config = typeof stats === "object" ? stats : void 0;
-	return {
-		dir: config?.location ?? getStatsDir(env),
-		retentionMonths: config?.retentionMonths
-	};
+//#endregion
+//#region src/cli/commands/lint/errors.ts
+const colors$1 = createColors({ force: true });
+function formatCancelledError(error, color) {
+	return `${color ? colors$1.red("error") : "error"} ${error.message}\n`;
 }
-async function writeRunStats(target, collector, result, cwd) {
-	const store = createJsonlStatsStore({
-		dir: target.dir,
-		retentionMonths: target.retentionMonths
-	});
-	try {
-		await store.record(createRunStat({
-			cwd,
-			durationMs: collector.durationMs(),
-			ruleCounts: {
-				cached: result.execution.cached,
-				cancelled: result.execution.cancelled,
-				completed: result.execution.completed,
-				failed: result.execution.failed,
-				planned: result.execution.planned
-			},
-			usage: result.usage
-		}));
-	} catch {}
+function formatRunError(error, color) {
+	const label = color ? colors$1.red("error") : "error";
+	const fileFailures = error.failures.filter((failure) => "file" in failure);
+	const groups = groupFailuresByRule(error.failures.filter((failure) => "job" in failure));
+	return [
+		`${label} ${error.message}`,
+		"",
+		...fileFailures.length > 0 ? [
+			`Failed Files ${fileFailures.length}`,
+			"",
+			...formatFileFailures(fileFailures, color)
+		] : [],
+		...groups.length > 0 ? [
+			`Failed Rules ${groups.length}`,
+			"",
+			...formatFailureGroups(groups, color)
+		] : []
+	].join("\n");
 }
-function normalizeReporterError(error) {
-	if (error instanceof Error) return error;
-	return new Error(error != null ? String(error) : "Unknown progress reporter error.");
+function formatFailureGroups(groups, color) {
+	const lines = [];
+	for (const [ruleId, group] of groups) {
+		const failLabel = color ? colors$1.bgRed(colors$1.bold(" FAIL ")) : "FAIL";
+		const targetLabel = group.length === 1 ? "target" : "targets";
+		lines.push(`${failLabel} ${ruleId} ${group.length} ${targetLabel}`);
+		for (const failure of group) {
+			lines.push(`  ${formatTarget(failure)}`);
+			lines.push(`    [${failure.kind}] ${failure.message}`);
+			for (const cause of failure.causes) {
+				const code = cause.code === void 0 ? "" : `[${cause.code}] `;
+				lines.push(`      Caused by: ${code}${cause.message}`);
+			}
+		}
+		lines.push("");
+	}
+	return lines;
+}
+function formatFileFailures(failures, color) {
+	const lines = [];
+	for (const failure of failures) {
+		const failLabel = color ? colors$1.bgRed(colors$1.bold(" FAIL ")) : "FAIL";
+		lines.push(`${failLabel} ${failure.file.path}`);
+		lines.push(`  [${failure.kind}] ${failure.message}`);
+		lines.push("");
+	}
+	return lines;
+}
+function formatTarget(failure) {
+	const target = failure.job.target.name ? `${failure.job.target.kind} ${failure.job.target.name}` : failure.job.target.kind;
+	return `${failure.job.inputPath} > ${target}`;
+}
+function groupFailuresByRule(failures) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const failure of failures) {
+		const group = groups.get(failure.job.ruleId) ?? [];
+		group.push(failure);
+		groups.set(failure.job.ruleId, group);
+	}
+	return [...groups];
 }
 //#endregion
 //#region src/cli/commands/lint/index.ts
@@ -3779,78 +4381,101 @@ const lint = defineCommand({
 	arguments: "[...files]",
 	default: true,
 	description: "Run alint",
-	name: "lint"
+	name: "lint",
+	options: [{
+		description: "Lint only staged, unstaged, and untracked files",
+		flags: "--dirty"
+	}]
 });
 async function assertConfigExists(cwd, configPath) {
 	const resolvedConfigPath = resolve(cwd, configPath);
 	try {
 		if (!(await stat(resolvedConfigPath)).isFile()) throw new Error(`Config file "${configPath}" is not a file.`);
 	} catch (error) {
-		if (isNodeError(error) && error.code === "ENOENT") throw new Error(`Config file "${configPath}" does not exist.`);
+		if (isNodeErrorCode(error, "ENOENT")) throw new Error(`Config file "${configPath}" does not exist.`);
 		throw error;
 	}
 }
-function isNodeError(error) {
-	return error instanceof Error && "code" in error;
-}
 async function runLintCommand(files, options, io, interceptConsoleOutput) {
-	if (options.config) await assertConfigExists(io.cwd, options.config);
-	const session = await createRunSession(io, { configPath: options.config });
+	if (options.dirty && files.length > 0) {
+		io.stderr.write("The --dirty option does not accept file arguments.\n");
+		return 2;
+	}
+	const cwd = options.dirty ? await findGitRoot(io.cwd) : io.cwd;
+	const runIo = cwd === io.cwd ? io : {
+		...io,
+		cwd
+	};
+	if (options.config) await assertConfigExists(cwd, options.config);
+	let changedLines;
+	let config;
+	let targets;
+	if (options.dirty) {
+		config = await loadAlintConfig(cwd, options.config);
+		const dirtyTargets = await findDirtyLintTargets(config, cwd);
+		changedLines = dirtyTargets.changedLines;
+		targets = dirtyTargets;
+		if (targets.files.length === 0) return 0;
+	}
+	const session = await createRunSession(runIo, config === void 0 ? { configPath: options.config } : { config });
 	try {
-		const runner = resolveRunnerConfig(session.runner, options);
-		const progress = shouldEnableProgress(options, io) ? createCliProgressReporter({
-			color: io.stderr.isTTY === true,
-			columns: io.stderr.columns ?? 80,
-			cwd: io.cwd,
-			isTty: io.stderr.isTTY === true,
-			rows: io.stderr.rows,
-			write: (chunk) => io.stderr.write(chunk)
+		const progress = shouldEnableProgress(options, runIo) ? createCliProgressReporter({
+			color: runIo.stderr.isTTY === true,
+			columns: runIo.stderr.columns ?? 80,
+			cwd,
+			isTty: runIo.stderr.isTTY === true,
+			rows: runIo.stderr.rows,
+			write: (chunk) => runIo.stderr.write(chunk)
 		}) : void 0;
 		const restoreProgressConsole = progress ? interceptConsoleOutput({ write: progress.write }) : void 0;
-		const statsTarget = resolveStatsWrite(runner?.stats, io.env);
-		const statsCollector = statsTarget ? createStatsCollector() : void 0;
-		const persistStats = async (runResult) => {
-			if (statsTarget && statsCollector) await writeRunStats(statsTarget, statsCollector, runResult, io.cwd);
-		};
+		const visibleResult = (runResult) => changedLines === void 0 ? runResult : filterResultToChangedLines(runResult, {
+			changedLines,
+			cwd
+		});
 		const writeResult = (runResult) => {
-			io.stdout.write(formatDiagnostics(options.format, runResult, { color: io.stdout.isTTY === true }));
+			runIo.stdout.write(formatDiagnostics(options.format, visibleResult(runResult), { color: runIo.stdout.isTTY === true }));
 		};
+		const targetSelection = targets === void 0 ? { inputs: files } : { targets };
 		let result;
 		try {
-			result = await session.run({
+			result = await executeLint({
+				...targetSelection,
 				cacheOnly: options.cacheOnly,
-				files,
+				io: runIo,
 				modelOverride: options.model,
 				outputLanguage: options.outputLanguage,
-				progress: mergeProgressReporters(progress?.reporter, statsCollector?.reporter),
-				runner
+				progress: progress?.reporter,
+				runnerOptions: options,
+				session
 			});
 		} catch (error) {
-			restoreProgressConsole?.();
-			progress?.dispose();
 			if (error instanceof NoFilesFoundError) {
-				io.stderr.write(`${error.message}\n`);
+				runIo.stderr.write(`${error.message}\n`);
 				return 2;
 			}
+			if (error instanceof AlintCachePersistenceError) {
+				writeResult(error.result);
+				const message = errorMessageFrom(error.cause) ?? error.message;
+				runIo.stderr.write(`Cache persistence failed: ${message}\n`);
+				return 1;
+			}
 			if (error instanceof AlintRunError) {
-				await persistStats(error.result);
 				writeResult(error.result);
-				io.stderr.write(formatRunError(error, io.stderr.isTTY === true));
+				runIo.stderr.write(formatRunError(error, runIo.stderr.isTTY === true));
 				return 2;
 			}
 			if (error instanceof AlintRunCancelledError) {
-				await persistStats(error.result);
 				writeResult(error.result);
-				io.stderr.write(formatCancelledError(error, io.stderr.isTTY === true));
+				runIo.stderr.write(formatCancelledError(error, runIo.stderr.isTTY === true));
 				return 2;
 			}
 			throw error;
+		} finally {
+			restoreProgressConsole?.();
+			progress?.dispose();
 		}
-		restoreProgressConsole?.();
-		progress?.dispose();
-		await persistStats(result);
 		writeResult(result);
-		return result.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
+		return visibleResult(result).diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
 	} finally {
 		await session.shutdown();
 	}
@@ -3862,10 +4487,10 @@ function shouldEnableProgress(options, io) {
 //#endregion
 //#region src/cli/commands/lsp/index.ts
 const lsp = defineCommand({
-	action: async (context) => (await import("./server-DgJa6R5l.mjs")).startLspServer(context.io),
+	action: async (context) => (await import("./server-C-kuoGl1.mjs")).startLspServer(context.io),
 	description: "Run alint as a language server over stdio",
 	examples: [["# Point an editor at the project's own alint", "alint lsp"].join("\n")],
-	help: ["Serve alint diagnostics over the Language Server Protocol on stdin/stdout.", "The server is cache-first: it publishes findings that are already cached and never calls a model on its own. Runs that spend tokens happen only through the `alint.runFile` and `alint.runWorkspace` commands."].join("\n\n"),
+	help: ["Serve alint diagnostics over the Language Server Protocol on stdin/stdout.", "The server is cache-first. It publishes diagnostics that are already cached, and it never calls a model on its own. Runs that spend tokens happen only through the `alint.runFile` and `alint.runWorkspace` commands."].join("\n\n"),
 	name: "lsp",
 	options: [{
 		description: "Use stdio transport (default; accepted for client compatibility)",
@@ -3901,14 +4526,14 @@ async function inspectOutputFile(io, file, options) {
 	try {
 		text = await readFile(filePath, "utf8");
 	} catch (error) {
-		io.stderr.write(`Could not read output file "${file}": ${errorMessageFrom$1(error)}\n`);
+		io.stderr.write(`Could not read output file "${file}": ${errorMessageFrom(error)}\n`);
 		return 2;
 	}
 	let parsed;
 	try {
 		parsed = JSON.parse(text);
 	} catch (error) {
-		io.stderr.write(`Could not parse output file "${file}": ${errorMessageFrom$1(error)}\n`);
+		io.stderr.write(`Could not parse output file "${file}": ${errorMessageFrom(error)}\n`);
 		return 2;
 	}
 	if (!isRunResult(parsed)) {
@@ -3918,7 +4543,7 @@ async function inspectOutputFile(io, file, options) {
 	try {
 		io.stdout.write(formatDiagnostics(options.format, parsed, { color: io.stdout.isTTY === true }));
 	} catch (error) {
-		io.stderr.write(`${errorMessageFrom$1(error)}\n`);
+		io.stderr.write(`${errorMessageFrom(error)}\n`);
 		return 2;
 	}
 	return parsed.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
@@ -4443,7 +5068,7 @@ async function runStatsCommand(options, io) {
 		}));
 		return 0;
 	} catch (error) {
-		io.stderr.write(`${errorMessageFrom$1(error) ?? "Failed to read stats."}\n`);
+		io.stderr.write(`${errorMessageFrom(error) ?? "Failed to read stats."}\n`);
 		return 2;
 	}
 }
@@ -4479,6 +5104,7 @@ function statsLocation(stats) {
 const commandTree = [
 	setup,
 	config,
+	integrations,
 	plugin,
 	output,
 	defineCommand({
@@ -4619,4 +5245,4 @@ function shouldCaptureHelp(argv) {
 	return argv.includes("--help") || argv.includes("-h");
 }
 //#endregion
-export { formatJson as a, formatStylish as i, createRunSession as n, formatDiagnostics as r, executeCli as t };
+export { createRunSession as a, formatJson as i, formatDiagnostics as n, formatStylish as r, executeCli as t };