@alint-js/cli 0.0.38 → 0.1.1

package/dist/{cli-BQFW2w-L.mjs → cli-B_wKMxdx.mjs}

@@ -2,7 +2,7 @@ import process from "node:process";
 import { inspect } from "node:util";
 import { cac } from "cac";
 import { appendFile, mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
-import { getGlobalSetupConfigPath, getProjectSetupConfigPath, getStatsDir, installStaticPlugins, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, writeSetupConfig } from "@alint-js/config";
+import { addProviderModels, getGlobalSetupConfigPath, getProjectSetupConfigPath, getStatsDir, installStaticPlugins, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, pruneProviderModels, removeProviderModels, replaceSetupProvider, setProviderEndpoint, setProviderHeader, unsetProviderHeader, writeSetupConfig } from "@alint-js/config";
 import { AlintRunCancelledError, AlintRunError, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, resolveConfigForDirectory, resolveConfigForFile, runAlint } from "@alint-js/core";
 import { isAbsolute, join, relative, resolve } from "pathe";
 import { getBorderCharacters, table } from "table";
@@ -16,7 +16,12 @@ import Gitignore from "gitignore-fs";
 import { Minimatch, minimatch } from "minimatch";
 import { errorMessageFrom as errorMessageFrom$1 } from "@moeru/std";
 //#region package.json
-var version = "0.0.38";
+var version = "0.1.1";
+//#endregion
+//#region src/cli/output.ts
+function escapeLineValue(value) {
+	return JSON.stringify(value).slice(1, -1).replace(/[\u0080-\u009F\u2028\u2029]/gu, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
 //#endregion
 //#region src/cli/commands/command.ts
 function defineCommand(node) {
@@ -41,6 +46,13 @@ function dispatchCommand(context, node, args, options, path) {
 	const child = node.children?.find((item) => item.name === subcommand || item.alias?.includes(subcommand ?? ""));
 	if (child) return dispatchCommand(context, child, restArgs, options, [...path, child.name]);
 	if (!node.action) return Promise.resolve(reportUnknownCommand(context, path, args));
+	if (node.exactArguments === true) {
+		const unexpectedArgument = args[node.arguments?.split(/\s+/u).filter(Boolean).length ?? 0];
+		if (unexpectedArgument !== void 0) {
+			context.io.stderr.write(`unexpected argument "${escapeLineValue(unexpectedArgument)}". usage: alint ${formatUsagePattern(path, node)}.\n`);
+			return Promise.resolve(2);
+		}
+	}
 	return Promise.resolve(node.action(context, ...parseCommandArguments(node, args), options));
 }
 function formatChildCommandHelp(parentPath, child) {
@@ -197,6 +209,7 @@ function shouldSkipOptionValue(arg) {
 		"--interval",
 		"--metric",
 		"--model",
+		"--provider",
 		"--provider-endpoint",
 		"--provider-header",
 		"--provider-id",
@@ -234,6 +247,13 @@ async function runConfigInspectCommand(path, configPath, io) {
 }
 //#endregion
 //#region src/cli/provider-registry.ts
+function formatDuplicateModelIdentity(identity) {
+	return [
+		`model "${escapeLineValue(identity)}" is configured more than once.`,
+		"remove duplicate provider/model definitions from the setup configuration.",
+		""
+	].join("\n");
+}
 const providerSetupSources = [
 	{
 		defaultEndpoint: "http://127.0.0.1:8317/v1",
@@ -247,6 +267,20 @@ const providerSetupSources = [
 		probeModels: true,
 		value: "custom"
 	},
+	{
+		defaultEndpoint: "https://api.cerebras.ai/v1",
+		defaultProviderId: "cerebras",
+		label: "Cerebras",
+		probeModels: true,
+		value: "cerebras"
+	},
+	{
+		defaultEndpoint: "https://api.groq.com/openai/v1",
+		defaultProviderId: "groq",
+		label: "Groq",
+		probeModels: true,
+		value: "groq"
+	},
 	{
 		defaultEndpoint: "http://localhost:11434/v1",
 		label: "Ollama",
@@ -277,8 +311,17 @@ function createProviderId(endpoint, existingIds) {
 		if (!existingIds.has(candidate)) return candidate;
 	}
 }
-function findModel(config, request) {
-	return flattenModels(config).find(({ model }) => model.id === request || model.name === request || (model.aliases ?? []).includes(request));
+function findModels(config, request) {
+	const candidates = flattenModels(config);
+	const canonicalCandidates = candidates.filter((candidate) => canonicalIdentity(candidate) === request);
+	if (canonicalCandidates.length > 0) return canonicalCandidates;
+	return candidates.filter((candidate) => {
+		return [
+			candidate.model.id,
+			candidate.model.name,
+			...candidate.model.aliases ?? []
+		].filter((name) => name !== void 0).some((name) => name === request || `${candidate.provider.id}/${name}` === request);
+	});
 }
 function findProviderSetupSource(value) {
 	return providerSetupSources.find((source) => source.value === value);
@@ -293,6 +336,23 @@ function flattenModels(config) {
 		provider
 	})));
 }
+function formatAmbiguousModels(request, candidates) {
+	const candidatesByIdentity = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const identity = canonicalIdentity(candidate);
+		const matchingCandidates = candidatesByIdentity.get(identity) ?? [];
+		matchingCandidates.push(candidate);
+		candidatesByIdentity.set(identity, matchingCandidates);
+	}
+	const duplicateIdentity = [...candidatesByIdentity].find(([, matchingCandidates]) => matchingCandidates.length > 1)?.[0];
+	if (duplicateIdentity !== void 0) return formatDuplicateModelIdentity(duplicateIdentity);
+	const choices = [...candidatesByIdentity.keys()];
+	return `${[
+		`ambiguous model "${escapeLineValue(request)}".`,
+		"specify a provider-qualified model:",
+		...choices.map((choice) => `  ${escapeLineValue(choice)}`)
+	].join("\n")}\n`;
+}
 function formatModelList(config) {
 	return formatTable([[
 		"id",
@@ -343,13 +403,19 @@ function formatProviderShow(provider) {
 	if (headerKeys.length > 0) lines.push(`headers: ${headerKeys.join(", ")}`);
 	return `${lines.join("\n")}\n`;
 }
+const httpTokenPattern = /^[\w^`\-!#$%&'*+.|~]+$/u;
+function isValidProviderHeaderName(name) {
+	return httpTokenPattern.test(name);
+}
 function parseHeaderList(headers) {
 	if (headers.length === 0) return;
 	const parsedHeaders = {};
 	for (const header of headers) {
 		const separatorIndex = header.indexOf("=");
-		if (separatorIndex <= 0) throw new Error(`Invalid provider header "${header}". Expected Key=Value.`);
-		parsedHeaders[header.slice(0, separatorIndex)] = header.slice(separatorIndex + 1);
+		if (separatorIndex <= 0) throw new Error("Invalid provider header. Expected Key=Value.");
+		const name = header.slice(0, separatorIndex);
+		if (!isValidProviderHeaderName(name)) throw new Error("Invalid provider header name. Expected an HTTP field-name token.");
+		parsedHeaders[name] = header.slice(separatorIndex + 1);
 	}
 	return parsedHeaders;
 }
@@ -357,8 +423,11 @@ async function probeModels(endpoint, headers = {}) {
 	const response = await fetch(buildModelsUrl(endpoint), { headers });
 	if (!response.ok) throw new Error(`GET ${buildModelsUrl(endpoint)} returned ${response.status}.`);
 	const body = await response.json();
-	if (!Array.isArray(body.data)) throw new TypeError("Expected OpenAI-compatible models response with data array.");
-	return body.data.map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0);
+	if (!isRecord$1(body) || !Array.isArray(body.data) || !body.data.every(isModelRecord)) throw new TypeError("Expected OpenAI-compatible models response with data array.");
+	return body.data.map((model) => model.id);
+}
+function canonicalIdentity(candidate) {
+	return `${candidate.provider.id}/${candidate.model.id}`;
 }
 function formatTable(rows) {
 	if (rows.length <= 1) return "";
@@ -371,17 +440,36 @@ function formatTable(rows) {
 		drawHorizontalLine: () => false
 	});
 }
+function isModelRecord(value) {
+	return isRecord$1(value) && typeof value.id === "string" && value.id.length > 0;
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function normalizeProviderIdBase(value) {
 	return value.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase() || "provider";
 }
 //#endregion
 //#region src/cli/commands/config/setup-config.ts
+function formatUnknownProvider(providerId, scope) {
+	const hint = scope === "local" ? " Remove --local to inspect global configuration." : " Add --local to inspect project-local configuration.";
+	return `unknown provider "${escapeLineValue(providerId)}" in ${scope} setup config.${hint}\n`;
+}
 async function loadMergedSetupConfig(io) {
 	const globalSetupConfigPath = getGlobalSetupConfigPath(io.env ?? process.env);
 	const projectSetupConfigPath = getProjectSetupConfigPath(io.cwd);
 	const [globalSetupConfig, projectSetupConfig] = await Promise.all([loadSetupConfig(globalSetupConfigPath), loadSetupConfig(projectSetupConfigPath)]);
 	return mergeSetupConfigs(globalSetupConfig, projectSetupConfig);
 }
+async function loadScopedSetupConfig(io, local) {
+	const scope = local === true ? "local" : "global";
+	const path = scope === "local" ? getProjectSetupConfigPath(io.cwd) : getGlobalSetupConfigPath(io.env ?? process.env);
+	return {
+		config: await loadSetupConfig(path),
+		path,
+		scope
+	};
+}
 //#endregion
 //#region src/cli/commands/config/models/ls.ts
 const ls$1 = defineCommand({
@@ -396,61 +484,338 @@ const ls$1 = defineCommand({
 //#endregion
 //#region src/cli/commands/config/probe.ts
 function providerHeadersFromOptions(options) {
-	return parseHeaderList(toArray$1(options.providerHeader)) ?? {};
+	return parseHeaderList(toArray$2(options.providerHeader)) ?? {};
 }
-function toArray$1(value) {
+function toArray$2(value) {
 	if (value === void 0) return [];
 	return (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string");
 }
 //#endregion
+//#region src/cli/commands/config/models/probe.ts
+const probe$1 = defineCommand({
+	async action(context, options) {
+		if (!options.endpoint) {
+			context.io.stderr.write("config models probe requires --endpoint.\n");
+			return 2;
+		}
+		try {
+			const models = await probeModels(options.endpoint, providerHeadersFromOptions(options));
+			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`);
+			return 2;
+		}
+	},
+	description: "Probe OpenAI-compatible models",
+	examples: [["# Probe a provider endpoint and print available model ids", "alint config models probe --endpoint https://openrouter.ai/api/v1"].join("\n"), ["# Probe an endpoint that requires an authorization header", "alint config models probe --endpoint https://api.example.com/v1 --provider-header \"Authorization=Bearer $TOKEN\""].join("\n")],
+	help: ["Probe an OpenAI-compatible models endpoint before saving it in setup config.", "The command calls the provider models endpoint using the supplied endpoint and optional headers, then prints the model ids returned by that provider."].join("\n\n"),
+	name: "probe",
+	options: [{
+		description: "Provider endpoint",
+		flags: "--endpoint <url>"
+	}, {
+		description: "Provider header",
+		flags: "--provider-header <Key=Value>"
+	}]
+});
+//#endregion
+//#region src/cli/commands/config/models/prune.ts
+const prune$1 = defineCommand({
+	action: runPruneModelsCommand,
+	description: "Remove models unavailable from providers",
+	name: "prune",
+	options: [
+		{
+			description: "Provider id",
+			flags: "--provider <id>"
+		},
+		{
+			description: "Read and write project-local config",
+			flags: "--local"
+		},
+		{
+			description: "Disable interactive confirmation",
+			flags: "-N, --no-interactive"
+		},
+		{
+			description: "Confirm model deletion",
+			flags: "--yes"
+		}
+	]
+});
+/**
+* Removes configured models absent from their providers' model registries.
+*
+* Triggering workflow:
+*
+* {@link registerCommandTree}
+*   -> `config models prune`
+*     -> {@link runPruneModelsCommand}
+*
+* Upstream:
+* - {@link dispatchCommand}
+*
+* Downstream:
+* - {@link confirmPruneModels}
+* - {@link probeModels}
+* - {@link pruneProviderModels}
+* - {@link writeSetupConfig}
+*/
+async function runPruneModelsCommand(context, options, confirm = confirmPruneModels) {
+	if (Array.isArray(options.provider)) {
+		context.io.stderr.write("config models prune accepts --provider only once.\n");
+		return 2;
+	}
+	const { config, path, scope } = await loadScopedSetupConfig(context.io, options.local);
+	const providers = options.provider === void 0 ? config.providers : config.providers.filter((provider) => provider.id === options.provider);
+	if (options.provider !== void 0 && providers.length === 0) {
+		context.io.stderr.write(formatUnknownProvider(options.provider, scope));
+		return 2;
+	}
+	const duplicateProviderId = providers.find((provider, providerIndex) => providers.findIndex((candidate) => candidate.id === provider.id) !== providerIndex)?.id;
+	if (duplicateProviderId !== void 0) {
+		context.io.stderr.write([
+			`provider "${escapeLineValue(duplicateProviderId)}" is configured more than once.`,
+			"remove duplicate provider definitions from the setup configuration.",
+			""
+		].join("\n"));
+		return 2;
+	}
+	const plans = [];
+	let hadFailure = false;
+	for (const provider of providers) {
+		let remoteModelIds;
+		try {
+			remoteModelIds = new Set(await probeModels(provider.endpoint, provider.headers));
+		} catch (error) {
+			hadFailure = true;
+			context.io.stderr.write(`failed to probe provider "${escapeLineValue(provider.id)}" at "${escapeLineValue(provider.endpoint)}": ${classifyProbeFailure(error)}.\n`);
+			continue;
+		}
+		const removedModels = provider.models.filter((model) => !remoteModelIds.has(model.id));
+		const defaultModel = removedModels.find((model) => (model.aliases ?? []).includes("default"));
+		if (defaultModel !== void 0) {
+			hadFailure = true;
+			context.io.stderr.write(`cannot prune default model "${escapeLineValue(provider.id)}/${escapeLineValue(defaultModel.id)}". select another default first.\n`);
+			continue;
+		}
+		if (removedModels.length > 0) plans.push({
+			provider,
+			remoteModelIds,
+			removedModels
+		});
+	}
+	if (plans.length === 0) {
+		context.io.stdout.write("no models to prune.\n");
+		return hadFailure ? 2 : 0;
+	}
+	context.io.stdout.write([
+		"Models to prune:",
+		...plans.flatMap((plan) => plan.removedModels.map((model) => `  ${escapeLineValue(plan.provider.id)}/${escapeLineValue(model.id)}`)),
+		""
+	].join("\n"));
+	if (context.setupNoInteractive && options.yes !== true) {
+		context.io.stderr.write("config models prune requires --yes in --no-interactive mode.\n");
+		return 2;
+	}
+	if (!context.setupNoInteractive && options.yes !== true) {
+		if (context.io.stdin?.isTTY !== true || context.io.stdout.isTTY !== true) {
+			context.io.stderr.write("config models prune requires a TTY or -N --yes.\n");
+			return 2;
+		}
+		if (await confirm() !== "confirmed") return 1;
+	}
+	await writeSetupConfig(path, applyPlans(config, plans));
+	return hadFailure ? 2 : 0;
+}
+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 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";
+	if (error instanceof SyntaxError) return "provider returned invalid JSON";
+	return "model request failed";
+}
+async function confirmPruneModels() {
+	const prompts = await import("@clack/prompts");
+	const confirmed = await prompts.confirm({ message: "Remove these configured models?" });
+	if (prompts.isCancel(confirmed)) return "cancelled";
+	return confirmed ? "confirmed" : "declined";
+}
+//#endregion
+//#region src/cli/commands/config/models/target.ts
+function resolveExactModelTarget(config, request, requestedProviderId) {
+	const separatorIndex = request.indexOf("/");
+	const qualifier = separatorIndex === -1 ? void 0 : request.slice(0, separatorIndex);
+	const qualifiedProviders = qualifier === void 0 ? [] : config.providers.filter((provider) => provider.id === qualifier);
+	const qualifiedProviderId = qualifiedProviders[0]?.id;
+	const modelId = qualifiedProviders.length === 0 ? request : request.slice(separatorIndex + 1);
+	if (qualifiedProviderId !== void 0 && requestedProviderId !== void 0 && qualifiedProviderId !== requestedProviderId) return {
+		qualifiedProviderId,
+		requestedProviderId,
+		status: "conflict"
+	};
+	const requestedProviders = requestedProviderId === void 0 ? [] : config.providers.filter((provider) => provider.id === requestedProviderId);
+	if (requestedProviderId !== void 0 && requestedProviders.length === 0) return {
+		providerId: requestedProviderId,
+		status: "unknown-provider"
+	};
+	const selectedProviders = qualifiedProviders.length > 0 ? qualifiedProviders : requestedProviders;
+	const selectedProvider = selectedProviders[0];
+	if (selectedProvider !== void 0 && selectedProviders.length > 1) return {
+		providerId: selectedProvider.id,
+		status: "duplicate-provider"
+	};
+	const matchingProviders = (selectedProviders.length > 0 ? selectedProviders : config.providers).filter((provider) => provider.models.some((model) => model.id === modelId));
+	if (selectedProviders.length === 0) {
+		const duplicateProvider = matchingProviders.find((provider) => config.providers.filter((candidate) => candidate.id === provider.id).length > 1);
+		if (duplicateProvider !== void 0) return {
+			providerId: duplicateProvider.id,
+			status: "duplicate-provider"
+		};
+	}
+	const candidates = matchingProviders.flatMap((provider) => {
+		const model = findExactModel(provider, modelId);
+		return model === void 0 ? [] : [{
+			model,
+			provider
+		}];
+	});
+	if (candidates.length === 0) return {
+		modelId,
+		provider: selectedProviders[0],
+		status: "missing"
+	};
+	if (candidates.length > 1) return {
+		candidates: candidates.map((candidate) => ({
+			modelId: candidate.model.id,
+			providerId: candidate.provider.id
+		})),
+		status: "ambiguous"
+	};
+	return {
+		...candidates[0],
+		status: "found"
+	};
+}
+function findExactModel(provider, modelId) {
+	const matches = provider.models.filter((model) => model.id === modelId);
+	return matches.find((model) => model.aliases?.includes("default")) ?? matches[0];
+}
+//#endregion
+//#region src/cli/commands/config/models/rm.ts
+const rm$1 = defineCommand({
+	action: runRemoveModelCommand,
+	arguments: "<model-id>",
+	description: "Remove a configured model",
+	exactArguments: true,
+	name: "rm",
+	options: [{
+		description: "Provider id",
+		flags: "--provider <id>"
+	}, {
+		description: "Read and write project-local config",
+		flags: "--local"
+	}]
+});
+/**
+* Removes an exact model ID from the explicitly selected setup-config scope.
+*
+* Triggering workflow:
+*
+* {@link registerCommandTree}
+*   -> `config models rm`
+*     -> {@link runRemoveModelCommand}
+*
+* Upstream:
+* - {@link dispatchCommand}
+*
+* Downstream:
+* - {@link resolveExactModelTarget}
+* - {@link removeProviderModels}
+* - {@link writeSetupConfig}
+*/
+async function runRemoveModelCommand(context, request, options) {
+	if (Array.isArray(options.provider)) {
+		context.io.stderr.write("config models rm accepts --provider only once.\n");
+		return 2;
+	}
+	const { config, path, scope } = await loadScopedSetupConfig(context.io, options.local);
+	const target = resolveExactModelTarget(config, request, options.provider);
+	if (target.status === "conflict") {
+		context.io.stderr.write(`model provider "${escapeLineValue(target.qualifiedProviderId)}" conflicts with --provider "${escapeLineValue(target.requestedProviderId)}".\n`);
+		return 2;
+	}
+	if (target.status === "unknown-provider") {
+		context.io.stderr.write(formatUnknownProvider(target.providerId, scope));
+		return 2;
+	}
+	if (target.status === "ambiguous") {
+		context.io.stderr.write([
+			`ambiguous model id "${escapeLineValue(request)}".`,
+			"specify <provider>/<model-id> or pass --provider <provider-id>:",
+			...target.candidates.map((candidate) => `  ${escapeLineValue(candidate.providerId)}/${escapeLineValue(candidate.modelId)}`),
+			""
+		].join("\n"));
+		return 2;
+	}
+	if (target.status === "duplicate-provider") {
+		context.io.stderr.write([
+			`provider "${escapeLineValue(target.providerId)}" is configured more than once.`,
+			"remove duplicate provider definitions from the setup configuration.",
+			""
+		].join("\n"));
+		return 2;
+	}
+	if (target.status === "missing") return 0;
+	if ((target.model.aliases ?? []).includes("default")) {
+		context.io.stderr.write(`cannot remove default model "${escapeLineValue(target.provider.id)}/${escapeLineValue(target.model.id)}". select another default first.\n`);
+		return 2;
+	}
+	await writeSetupConfig(path, removeProviderModels(config, target.provider.id, /* @__PURE__ */ new Set([target.model.id])));
+	context.io.stdout.write(`removed model: ${escapeLineValue(target.provider.id)}/${escapeLineValue(target.model.id)}\nscope: ${scope}\n`);
+	return 0;
+}
+//#endregion
 //#region src/cli/commands/config/models/models.ts
 const models = defineCommand({
 	children: [
-		defineCommand({
-			async action(context, options) {
-				if (!options.endpoint) {
-					context.io.stderr.write("config models probe requires --endpoint.\n");
-					return 2;
-				}
-				try {
-					const models = await probeModels(options.endpoint, providerHeadersFromOptions(options));
-					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`);
-					return 2;
-				}
-			},
-			description: "Probe OpenAI-compatible models",
-			examples: [["# Probe a provider endpoint and print available model ids", "alint config models probe --endpoint https://openrouter.ai/api/v1"].join("\n"), ["# Probe an endpoint that requires an authorization header", "alint config models probe --endpoint https://api.example.com/v1 --provider-header \"Authorization=Bearer $TOKEN\""].join("\n")],
-			help: ["Probe an OpenAI-compatible models endpoint before saving it in setup config.", "The command calls the provider models endpoint using the supplied endpoint and optional headers, then prints the model ids returned by that provider."].join("\n\n"),
-			name: "probe",
-			options: [{
-				description: "Provider endpoint",
-				flags: "--endpoint <url>"
-			}, {
-				description: "Provider header",
-				flags: "--provider-header <Key=Value>"
-			}]
-		}),
+		probe$1,
+		prune$1,
 		ls$1,
 		defineCommand({
 			async action(context, model) {
-				const candidate = findModel(await loadMergedSetupConfig(context.io), model);
-				if (candidate === void 0) {
+				const candidates = findModels(await loadMergedSetupConfig(context.io), model);
+				if (candidates.length === 0) {
 					context.io.stderr.write(`unknown model "${model}".\n`);
 					return 2;
 				}
-				context.io.stdout.write(formatModelShow(candidate));
+				if (candidates.length > 1) {
+					context.io.stderr.write(formatAmbiguousModels(model, candidates));
+					return 2;
+				}
+				context.io.stdout.write(formatModelShow(candidates[0]));
 				return 0;
 			},
 			arguments: "<model>",
 			description: "Show configured model",
 			name: "show"
-		})
+		}),
+		rm$1
 	],
 	description: "Manage configured models",
-	help: ["Inspect, list, and probe model entries from alint setup configuration.", "Model entries describe the provider/model ids alint can use for model-backed rules. Probe endpoints before saving them when you want to verify what model ids a provider exposes."].join("\n\n"),
+	examples: [["# Remove an exact model from one provider", "alint config models rm qwen --provider ollama"].join("\n"), ["# Destructively remove models no longer reported by one provider", "alint config models prune --provider ollama -N --yes"].join("\n")],
+	help: [
+		"Inspect, list, and probe model entries from alint setup configuration. Remove exact entries when they are no longer needed.",
+		"Model entries describe the provider/model ids alint can use for model-backed rules. Probe endpoints before saving them when you want to verify what model ids a provider exposes.",
+		"Use a provider-qualified model such as ollama/qwen or pass --provider ollama when the same model id is configured for multiple providers.",
+		"Prune is destructive: it removes configured models absent from the provider response. Non-interactive pruning requires -N --yes.",
+		"Writes use global scope by default. Pass --local to select the current project's setup configuration."
+	].join("\n\n"),
 	name: "models"
 });
 //#endregion
@@ -492,6 +857,756 @@ const probe = defineCommand({
 	}]
 });
 //#endregion
+//#region src/cli/commands/config/providers/set.ts
+const set = defineCommand({
+	action: runSetProviderCommand,
+	arguments: "<key> <value>",
+	description: "Set a provider configuration field",
+	exactArguments: true,
+	name: "set",
+	options: [{
+		description: "Provider id",
+		flags: "--provider <id>"
+	}, {
+		description: "Read and write project-local config",
+		flags: "--local"
+	}]
+});
+/**
+* Sets one provider field in the explicitly selected setup-config scope.
+*
+* Triggering workflow:
+*
+* {@link registerCommandTree}
+*   -> `config providers set`
+*     -> {@link runSetProviderCommand}
+*
+* Upstream:
+* - {@link dispatchCommand}
+*
+* Downstream:
+* - {@link setProviderEndpoint}
+* - {@link setProviderHeader}
+* - {@link writeSetupConfig}
+*/
+async function runSetProviderCommand(context, key, value, options) {
+	const providerId = scalarProvider$1(options.provider);
+	if (Array.isArray(options.provider)) {
+		context.io.stderr.write("config providers set accepts --provider only once.\n");
+		return 2;
+	}
+	if (providerId === void 0) {
+		context.io.stderr.write("config providers set requires --provider.\n");
+		return 2;
+	}
+	const { config, path, scope } = await loadScopedSetupConfig(context.io, options.local);
+	if (!config.providers.some((provider) => provider.id === providerId)) {
+		context.io.stderr.write(formatUnknownProvider(providerId, scope));
+		return 2;
+	}
+	let nextConfig;
+	if (key === "endpoint") nextConfig = setProviderEndpoint(config, providerId, value);
+	else if (key.startsWith("headers.") && key.length > 8) {
+		const headerName = key.slice(8);
+		if (!isValidProviderHeaderName(headerName)) {
+			context.io.stderr.write("invalid provider header name. expected an HTTP field-name token.\n");
+			return 2;
+		}
+		nextConfig = setProviderHeader(config, providerId, headerName, value);
+	} else {
+		context.io.stderr.write(`unsupported provider key "${escapeLineValue(key)}". expected endpoint or headers.<name>.\n`);
+		return 2;
+	}
+	await writeSetupConfig(path, nextConfig);
+	context.io.stdout.write(`provider: ${escapeLineValue(providerId)}\nkey: ${escapeLineValue(key)}\nscope: ${scope}\n`);
+	return 0;
+}
+function scalarProvider$1(provider) {
+	return Array.isArray(provider) ? void 0 : provider;
+}
+//#endregion
+//#region src/cli/commands/config/providers/show.ts
+const show = defineCommand({
+	async action(context, providerId) {
+		const provider = (await loadMergedSetupConfig(context.io)).providers.find((item) => item.id === providerId);
+		if (provider === void 0) {
+			context.io.stderr.write(`unknown provider "${providerId}".\n`);
+			return 2;
+		}
+		context.io.stdout.write(formatProviderShow(provider));
+		return 0;
+	},
+	arguments: "<provider>",
+	description: "Show configured provider",
+	name: "show"
+});
+//#endregion
+//#region src/cli/commands/config/providers/unset.ts
+const unset = defineCommand({
+	action: runUnsetProviderCommand,
+	arguments: "<key>",
+	description: "Unset a provider configuration field",
+	exactArguments: true,
+	name: "unset",
+	options: [{
+		description: "Provider id",
+		flags: "--provider <id>"
+	}, {
+		description: "Read and write project-local config",
+		flags: "--local"
+	}]
+});
+/**
+* Unsets one provider header in the explicitly selected setup-config scope.
+*
+* Triggering workflow:
+*
+* {@link registerCommandTree}
+*   -> `config providers unset`
+*     -> {@link runUnsetProviderCommand}
+*
+* Upstream:
+* - {@link dispatchCommand}
+*
+* Downstream:
+* - {@link unsetProviderHeader}
+* - {@link writeSetupConfig}
+*/
+async function runUnsetProviderCommand(context, key, options) {
+	const providerId = scalarProvider(options.provider);
+	if (Array.isArray(options.provider)) {
+		context.io.stderr.write("config providers unset accepts --provider only once.\n");
+		return 2;
+	}
+	if (providerId === void 0) {
+		context.io.stderr.write("config providers unset requires --provider.\n");
+		return 2;
+	}
+	const { config, path, scope } = await loadScopedSetupConfig(context.io, options.local);
+	if (!config.providers.some((provider) => provider.id === providerId)) {
+		context.io.stderr.write(formatUnknownProvider(providerId, scope));
+		return 2;
+	}
+	if (key === "endpoint") {
+		context.io.stderr.write("provider endpoint cannot be unset.\n");
+		return 2;
+	}
+	if (!key.startsWith("headers.") || key.length === 8) {
+		context.io.stderr.write(`unsupported provider key "${escapeLineValue(key)}". expected headers.<name>.\n`);
+		return 2;
+	}
+	const headerName = key.slice(8);
+	if (!isValidProviderHeaderName(headerName)) {
+		context.io.stderr.write("invalid provider header name. expected an HTTP field-name token.\n");
+		return 2;
+	}
+	await writeSetupConfig(path, unsetProviderHeader(config, providerId, headerName));
+	context.io.stdout.write(`provider: ${escapeLineValue(providerId)}\nkey: ${escapeLineValue(key)}\nscope: ${scope}\n`);
+	return 0;
+}
+function scalarProvider(provider) {
+	return Array.isArray(provider) ? void 0 : provider;
+}
+//#endregion
+//#region src/cli/tui/provider-editor/model-selection.ts
+function applyDefaultAlias(config, target) {
+	return {
+		...config,
+		providers: config.providers.map((provider) => ({
+			...provider,
+			headers: provider.headers === void 0 ? void 0 : { ...provider.headers },
+			models: provider.models.map((model) => {
+				const aliasesWithoutDefault = (model.aliases ?? []).filter((alias) => alias !== "default");
+				const aliases = provider.id === target.providerId && model.id === target.modelId ? [...aliasesWithoutDefault, "default"] : aliasesWithoutDefault;
+				return {
+					...cloneModel(model),
+					aliases: aliases.length > 0 ? aliases : void 0
+				};
+			})
+		}))
+	};
+}
+function applyHeaderSelection(existingHeaders, retainedNames, replacements) {
+	const selectedNames = new Set(retainedNames.map(normalizeHeaderName));
+	const headersByName = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(existingHeaders)) {
+		const normalizedName = normalizeHeaderName(name);
+		if (selectedNames.has(normalizedName)) headersByName.set(normalizedName, [name, value]);
+	}
+	for (const [name, value] of Object.entries(replacements)) headersByName.set(normalizeHeaderName(name), [name, value]);
+	const headers = Object.fromEntries(headersByName.values());
+	return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function createDefaultModelCandidates(config, newProviderId, newModelIds) {
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	const newModelIdSet = new Set(newModelIds);
+	const allModels = config.providers.flatMap((provider) => provider.models.map((model) => ({
+		isCurrentDefault: (model.aliases ?? []).includes("default"),
+		isNew: provider.id === newProviderId && newModelIdSet.has(model.id),
+		model,
+		provider,
+		value: createDefaultModelCandidateValue(provider.id, model.id)
+	})));
+	const addCandidate = (candidate) => {
+		if (candidate === void 0 || seen.has(candidate.value)) return;
+		seen.add(candidate.value);
+		candidates.push({
+			isCurrentDefault: candidate.isCurrentDefault,
+			isNew: candidate.isNew,
+			label: `${candidate.provider.id} / ${candidate.model.id}`,
+			modelId: candidate.model.id,
+			providerId: candidate.provider.id,
+			value: candidate.value
+		});
+	};
+	addCandidate(allModels.find((candidate) => candidate.isCurrentDefault));
+	for (const modelId of newModelIds) addCandidate(allModels.find((candidate) => candidate.provider.id === newProviderId && candidate.model.id === modelId));
+	for (const candidate of allModels) addCandidate(candidate);
+	return candidates;
+}
+function createModelOptions(provider, discoveredIds) {
+	const discovered = new Set(discoveredIds);
+	const existing = firstModelsById(provider);
+	const optionIds = new Set(existing.keys());
+	const options = [...existing.values()].map((model) => ({
+		hint: discovered.has(model.id) ? void 0 : "not reported by provider",
+		label: model.id,
+		value: model.id
+	}));
+	for (const modelId of discoveredIds) {
+		if (optionIds.has(modelId)) continue;
+		optionIds.add(modelId);
+		options.push({
+			hint: "new",
+			label: modelId,
+			value: modelId
+		});
+	}
+	return options;
+}
+function modelsFromSelection(provider, selectedIds) {
+	const existing = firstModelsById(provider);
+	const models = [];
+	const selected = /* @__PURE__ */ new Set();
+	for (const modelId of selectedIds) {
+		if (selected.has(modelId)) continue;
+		selected.add(modelId);
+		const model = existing.get(modelId);
+		models.push(model === void 0 ? {
+			id: modelId,
+			name: modelId
+		} : cloneModel(model));
+	}
+	return models;
+}
+function normalizeHeaderName(name) {
+	return name.toLowerCase();
+}
+function cloneModel(model) {
+	return {
+		...model,
+		aliases: model.aliases === void 0 ? void 0 : [...model.aliases],
+		capabilities: model.capabilities === void 0 ? void 0 : [...model.capabilities],
+		defaultParams: model.defaultParams === void 0 ? void 0 : { ...model.defaultParams }
+	};
+}
+function createDefaultModelCandidateValue(providerId, modelId) {
+	return `${providerId}\u0000${modelId}`;
+}
+function firstModelsById(provider) {
+	const models = /* @__PURE__ */ new Map();
+	for (const model of provider?.models ?? []) if (!models.has(model.id)) models.set(model.id, model);
+	return models;
+}
+//#endregion
+//#region src/cli/tui/provider-editor/prompts.ts
+const backValue$1 = "__alint_back__";
+/**
+* Adapts Clack prompt results into the provider editor's reversible actions.
+*
+* Triggering workflow:
+*
+* {@link runProviderEditor}
+*   -> {@link createProviderEditorPrompts}
+*     -> `provider-editor.prompt`
+*       -> {@link ProviderEditorPromptPort}
+*
+* Upstream:
+* - {@link runProviderEditor}
+*
+* Downstream:
+* - Clack terminal prompts and {@link probeModels}
+*
+* Cancellation and Back use tagged results, so submitted text cannot collide
+* with control values. Probe failures render in the spinner and return no models.
+*/
+function createProviderEditorPrompts(prompts) {
+	return {
+		async confirm(summary) {
+			return selectionResult(prompts, await prompts.select({
+				message: summary,
+				options: withBackOption([{
+					label: "Yes",
+					value: "yes"
+				}, {
+					label: "No",
+					value: "no"
+				}])
+			}));
+		},
+		async defaultAction(firstModelId) {
+			return selectionResult(prompts, await prompts.select({
+				message: `Add alias "default" to ${firstModelId}?`,
+				options: withBackOption([
+					{
+						label: "Yes",
+						value: "yes"
+					},
+					{
+						label: "No",
+						value: "no"
+					},
+					{
+						label: "Select another",
+						value: "selectAnother"
+					}
+				])
+			}));
+		},
+		async defaultModel(options) {
+			return selectionResult(prompts, await prompts.select({
+				message: "Select default model",
+				options: withBackOption(options)
+			}));
+		},
+		async endpoint(initialValue) {
+			return textResult(prompts, await prompts.text({
+				initialValue,
+				message: "Provider endpoint (type .. to go back)",
+				placeholder: initialValue ?? "https://example.test/v1",
+				validate: (value) => isBackInput(value ?? "") || (value ?? "").trim().length > 0 ? void 0 : "Provider endpoint is required."
+			}));
+		},
+		async headerInput() {
+			return textResult(prompts, await prompts.text({
+				message: "Headers (leave empty to skip; type .. to go back)",
+				placeholder: "Authorization=Bearer token, X-Test=true",
+				validate: (value) => {
+					if (isBackInput(value ?? "")) return;
+					try {
+						parseHeaderList(splitInput$1(value ?? ""));
+						return;
+					} catch {
+						return "Headers must be comma-separated Key=Value entries.";
+					}
+				}
+			}));
+		},
+		async manualModels() {
+			const value = textResult(prompts, await prompts.text({
+				message: "Models",
+				placeholder: "qwen:8b, qwen:32b; type .. to go back",
+				validate: (value) => isBackInput(value ?? "") || splitInput$1(value ?? "").length > 0 ? void 0 : "At least one model is required."
+			}));
+			return value.status === "submitted" ? submitted(splitInput$1(value.value)) : value;
+		},
+		async models(options, initialValues) {
+			const result = await prompts.multiselect({
+				initialValues,
+				message: "Select models",
+				options: withBackOption(options),
+				required: true
+			});
+			if (prompts.isCancel(result)) return { status: "cancelled" };
+			return result.includes(backValue$1) ? { status: "back" } : submitted(result);
+		},
+		async probe(endpoint, headers) {
+			const spinner = prompts.spinner();
+			spinner.start("Probing models");
+			try {
+				const models = await probeModels(endpoint, headers);
+				spinner.stop(models.length > 0 ? `Found ${models.length} models` : "No models discovered");
+				return models;
+			} catch (error) {
+				spinner.stop(formatProbeModelsFailure(endpoint, error));
+				return [];
+			}
+		},
+		async providerId(initialValue, editable) {
+			if (!editable) return submitted(initialValue);
+			return textResult(prompts, await prompts.text({
+				initialValue,
+				message: "Provider id (type .. to go back)",
+				validate: (value) => isBackInput(value ?? "") || (value ?? "").trim().length > 0 ? void 0 : "Provider id is required."
+			}));
+		},
+		async retainedHeaders(headerNames, initialValues) {
+			if (headerNames.length === 0) return submitted([]);
+			const result = await prompts.multiselect({
+				initialValues,
+				message: "Select existing headers to keep",
+				options: withBackOption(headerNames.map((name) => ({
+					label: name,
+					value: name
+				}))),
+				required: false
+			});
+			if (prompts.isCancel(result)) return { status: "cancelled" };
+			return result.includes(backValue$1) ? { status: "back" } : submitted(result);
+		}
+	};
+}
+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}`;
+}
+function isBackInput(value) {
+	return value.trim() === "..";
+}
+function withBackOption(options) {
+	return [...options, {
+		label: "Back",
+		value: backValue$1
+	}];
+}
+function selectionResult(prompts, result) {
+	if (prompts.isCancel(result)) return { status: "cancelled" };
+	return result === backValue$1 ? { status: "back" } : submitted(result);
+}
+function splitInput$1(value) {
+	return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function submitted(value) {
+	return {
+		status: "submitted",
+		value
+	};
+}
+function textResult(prompts, result) {
+	if (prompts.isCancel(result)) return { status: "cancelled" };
+	return isBackInput(result) ? { status: "back" } : submitted(result);
+}
+//#endregion
+//#region src/cli/tui/provider-editor/index.ts
+/**
+* Runs one provider create/update request as a reversible prompt state machine.
+*
+* Triggering workflow:
+*
+* {@link runInteractiveSetup}
+*   -> {@link runProviderEditor}
+*     -> `provider-editor.prompt-result`
+*       -> {@link ProviderEditorResult}
+*
+* Upstream:
+* - {@link runInteractiveSetup}
+*
+* Downstream:
+* - {@link createProviderEditorPrompts} and the caller-owned setup-config write
+*
+* The editor reads the selected-scope config, changes only its in-memory draft,
+* and returns without persistence on Back, cancellation, or a negative confirmation.
+*/
+async function runProviderEditor(input, promptPort) {
+	const prompts = promptPort ?? createProviderEditorPrompts(await import("@clack/prompts"));
+	const existingProvider = input.mode === "update" ? input.existingProvider : void 0;
+	const configuredHeaders = { ...existingProvider?.headers };
+	const initialHeaders = applyHeaderSelection(configuredHeaders, Object.keys(configuredHeaders), {}) ?? {};
+	const draft = {
+		discoveredModels: [],
+		endpoint: existingProvider?.endpoint ?? input.source.defaultEndpoint,
+		headerValues: initialHeaders,
+		providerId: existingProvider?.id,
+		retainedHeaderNames: Object.keys(initialHeaders)
+	};
+	let step = "endpoint";
+	while (true) {
+		if (step === "endpoint") {
+			const endpoint = await prompts.endpoint(draft.endpoint);
+			if (endpoint.status === "cancelled") return { status: "cancelled" };
+			if (endpoint.status === "back") return { status: "back" };
+			draft.endpoint = endpoint.value.trim();
+			step = "providerId";
+			continue;
+		}
+		if (step === "providerId") {
+			const initialProviderId = draft.providerId ?? createProviderId(draft.endpoint ?? "", new Set(input.config.providers.map((provider) => provider.id)));
+			const providerId = await prompts.providerId(initialProviderId, input.mode === "create");
+			if (providerId.status === "cancelled") return { status: "cancelled" };
+			if (providerId.status === "back") {
+				step = "endpoint";
+				continue;
+			}
+			draft.providerId = providerId.value.trim();
+			step = "retainedHeaders";
+			continue;
+		}
+		if (step === "retainedHeaders") {
+			const headerNames = Object.keys(draft.headerValues);
+			const retainedHeaders = await prompts.retainedHeaders(headerNames, draft.retainedHeaderNames.filter((name) => headerNames.includes(name)));
+			if (retainedHeaders.status === "cancelled") return { status: "cancelled" };
+			if (retainedHeaders.status === "back") {
+				step = "providerId";
+				continue;
+			}
+			draft.retainedHeaderNames = retainedHeaders.value;
+			step = "headerInput";
+			continue;
+		}
+		if (step === "headerInput") {
+			const headerInput = await prompts.headerInput();
+			if (headerInput.status === "cancelled") return { status: "cancelled" };
+			if (headerInput.status === "back") {
+				step = "retainedHeaders";
+				continue;
+			}
+			const replacements = parseHeaderList(splitInput(headerInput.value)) ?? {};
+			const retainedLogicalNames = new Set([...draft.retainedHeaderNames, ...Object.keys(replacements)].map(normalizeHeaderName));
+			draft.headerValues = applyHeaderSelection(draft.headerValues, Object.keys(draft.headerValues), replacements) ?? {};
+			draft.retainedHeaderNames = Object.keys(draft.headerValues).filter((name) => retainedLogicalNames.has(normalizeHeaderName(name)));
+			const headers = effectiveHeaders(draft) ?? {};
+			draft.discoveredModels = input.source.probeModels ? await prompts.probe(draft.endpoint ?? "", headers) : [];
+			step = "models";
+			continue;
+		}
+		if (step === "models") {
+			const options = createModelOptions(existingProvider, draft.discoveredModels);
+			const optionIds = options.map((option) => option.value);
+			const initialValues = draft.selectedModelIds === void 0 || draft.modelOptionIds === void 0 ? optionIds : optionIds.filter((modelId) => draft.selectedModelIds?.includes(modelId) === true || !draft.modelOptionIds?.includes(modelId));
+			draft.modelOptionIds = optionIds;
+			const selectedModels = options.length === 0 ? await prompts.manualModels() : await prompts.models(options, initialValues);
+			if (selectedModels.status === "cancelled") return { status: "cancelled" };
+			if (selectedModels.status === "back") {
+				step = "headerInput";
+				continue;
+			}
+			draft.selectedModelIds = selectedModels.value;
+			step = "defaultAction";
+			continue;
+		}
+		if (step === "defaultAction") {
+			const defaultAction = await prompts.defaultAction(draft.selectedModelIds?.[0] ?? "");
+			if (defaultAction.status === "cancelled") return { status: "cancelled" };
+			if (defaultAction.status === "back") {
+				step = "models";
+				continue;
+			}
+			draft.defaultAliasTarget = defaultAction.value === "yes" ? {
+				modelId: draft.selectedModelIds?.[0] ?? "",
+				providerId: draft.providerId ?? ""
+			} : void 0;
+			const removesCurrentDefault = existingProvider?.models.some((model) => model.aliases?.includes("default") === true && !draft.selectedModelIds?.includes(model.id)) === true;
+			step = defaultAction.value === "selectAnother" || defaultAction.value === "no" && removesCurrentDefault ? "defaultModel" : "confirm";
+			continue;
+		}
+		const provider = createProvider(input, draft);
+		if (step === "defaultModel") {
+			const provisionalConfig = input.mode === "update" ? replaceSetupProvider(input.config, provider) : mergeSetupConfigs(input.config, {
+				providers: [provider],
+				version: 1
+			});
+			const existingModelIds = new Set(existingProvider?.models.map((model) => model.id) ?? []);
+			const addedModelIds = provider.models.map((model) => model.id).filter((modelId) => !existingModelIds.has(modelId));
+			const candidates = createDefaultModelCandidates(provisionalConfig, provider.id, addedModelIds);
+			const selectedDefault = await prompts.defaultModel(candidates.map((candidate) => ({
+				hint: candidate.isCurrentDefault ? "current default" : candidate.isNew ? "new" : void 0,
+				label: candidate.label,
+				value: candidate.value
+			})));
+			if (selectedDefault.status === "cancelled") return { status: "cancelled" };
+			if (selectedDefault.status === "back") {
+				step = "defaultAction";
+				continue;
+			}
+			const candidate = candidates.find((item) => item.value === selectedDefault.value);
+			if (candidate === void 0) return { status: "cancelled" };
+			draft.defaultAliasTarget = {
+				modelId: candidate.modelId,
+				providerId: candidate.providerId
+			};
+			step = "confirm";
+			continue;
+		}
+		const confirmed = await prompts.confirm(createSummary(input, provider, draft.defaultAliasTarget));
+		if (confirmed.status === "cancelled" || confirmed.status === "submitted" && confirmed.value === "no") return { status: "cancelled" };
+		if (confirmed.status === "back") {
+			step = "defaultAction";
+			continue;
+		}
+		return {
+			defaultAliasTarget: draft.defaultAliasTarget,
+			provider,
+			status: "confirmed"
+		};
+	}
+}
+function createProvider(input, draft) {
+	return {
+		...input.existingProvider,
+		endpoint: draft.endpoint ?? "",
+		headers: effectiveHeaders(draft),
+		id: draft.providerId ?? "",
+		models: modelsFromSelection(input.existingProvider, draft.selectedModelIds ?? []),
+		type: "openai-compatible"
+	};
+}
+function createSummary(input, provider, defaultAliasTarget) {
+	const existingModelIds = new Set(input.existingProvider?.models.map((model) => model.id) ?? []);
+	const nextModelIds = new Set(provider.models.map((model) => model.id));
+	const additions = [...nextModelIds].filter((modelId) => !existingModelIds.has(modelId));
+	const removals = [...existingModelIds].filter((modelId) => !nextModelIds.has(modelId));
+	const defaultChange = defaultAliasTarget === void 0 ? "unchanged" : `${defaultAliasTarget.providerId}/${defaultAliasTarget.modelId}`;
+	return [
+		`${input.mode === "create" ? "Create" : "Update"} provider?`,
+		`Provider: ${escapeLineValue(provider.id)}`,
+		`Endpoint: ${escapeLineValue(provider.endpoint)}`,
+		`Headers: ${formatSummaryValues(Object.keys(provider.headers ?? {}))}`,
+		`Added models: ${formatSummaryValues(additions)}`,
+		`Removed models: ${formatSummaryValues(removals)}`,
+		`Default: ${defaultAliasTarget === void 0 ? defaultChange : escapeLineValue(defaultChange)}`
+	].join("\n");
+}
+function effectiveHeaders(draft) {
+	return applyHeaderSelection(draft.headerValues, draft.retainedHeaderNames, {});
+}
+function formatSummaryValues(values) {
+	return values.length > 0 ? values.map(escapeLineValue).join(", ") : "(none)";
+}
+function splitInput(value) {
+	return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+//#endregion
+//#region src/cli/commands/config/providers/update.ts
+const update = defineCommand({
+	action: runUpdateProviderCommand,
+	description: "Update a configured provider",
+	name: "update",
+	options: [
+		{
+			description: "Provider id",
+			flags: "--provider <id>"
+		},
+		{
+			description: "Read and write project-local config",
+			flags: "--local"
+		},
+		{
+			description: "Disable interactive editing",
+			flags: "-N, --no-interactive"
+		},
+		{
+			description: "Replace provider endpoint before probing",
+			flags: "--provider-endpoint <endpoint>"
+		},
+		{
+			description: "Add or replace provider header",
+			flags: "--provider-header <Key=Value>"
+		},
+		{
+			description: "Add a model in addition to probed models",
+			flags: "--provider-model <model>"
+		}
+	]
+});
+function providerUpdateSource(endpoint) {
+	const custom = findProviderSetupSource("custom");
+	try {
+		return findProviderSetupSourceByEndpoint(endpoint) ?? custom;
+	} catch {
+		return custom;
+	}
+}
+function mergeProviderHeaders(existing, replacements) {
+	const headers = { ...existing };
+	for (const [replacementName, replacementValue] of Object.entries(replacements ?? {})) {
+		for (const existingName of Object.keys(headers)) if (existingName.toLowerCase() === replacementName.toLowerCase()) delete headers[existingName];
+		headers[replacementName] = replacementValue;
+	}
+	return Object.keys(headers).length > 0 ? headers : void 0;
+}
+async function runNonInteractiveUpdate(context, options, providerEndpoint, existingProvider, config, path) {
+	let parsedHeaders;
+	try {
+		parsedHeaders = parseHeaderList(toArray$1(options.providerHeader));
+	} catch (error) {
+		context.io.stderr.write(`${errorMessageFrom(error) ?? "Invalid provider header."}\n`);
+		return 2;
+	}
+	const draft = {
+		...existingProvider,
+		endpoint: providerEndpoint ?? existingProvider.endpoint,
+		headers: mergeProviderHeaders(existingProvider.headers, parsedHeaders)
+	};
+	let remoteModelIds;
+	try {
+		remoteModelIds = await probeModels(draft.endpoint, draft.headers);
+	} catch (error) {
+		context.io.stderr.write(`failed to probe provider: ${errorMessageFrom(error) ?? "Unknown error."}\n`);
+		return 2;
+	}
+	await writeSetupConfig(path, addProviderModels(addProviderModels(replaceSetupProvider(config, draft), draft.id, remoteModelIds), draft.id, toArray$1(options.providerModel)));
+	return 0;
+}
+/**
+* Updates one provider in the explicitly selected setup-config scope.
+*
+* Triggering workflow:
+*
+* {@link registerCommandTree}
+*   -> `config providers update`
+*     -> {@link runUpdateProviderCommand}
+*
+* Upstream:
+* - {@link dispatchCommand}
+*
+* Downstream:
+* - {@link runProviderEditor}
+* - {@link probeModels}
+* - {@link writeSetupConfig}
+*/
+async function runUpdateProviderCommand(context, options) {
+	let providerEndpoint;
+	let providerId;
+	try {
+		providerId = scalarOption(options.provider, "--provider");
+		providerEndpoint = scalarOption(options.providerEndpoint, "--provider-endpoint");
+	} catch (error) {
+		context.io.stderr.write(`${errorMessageFrom(error) ?? "Invalid provider update option."}\n`);
+		return 2;
+	}
+	if (providerId === void 0) {
+		context.io.stderr.write("config providers update requires --provider.\n");
+		return 2;
+	}
+	const { config, path, scope } = await loadScopedSetupConfig(context.io, options.local);
+	const existingProvider = config.providers.find((provider) => provider.id === providerId);
+	if (existingProvider === void 0) {
+		context.io.stderr.write(formatUnknownProvider(providerId, scope));
+		return 2;
+	}
+	if (context.setupNoInteractive) return runNonInteractiveUpdate(context, options, providerEndpoint, existingProvider, config, path);
+	const result = await runProviderEditor({
+		config,
+		existingProvider,
+		io: context.io,
+		mode: "update",
+		source: providerUpdateSource(existingProvider.endpoint)
+	});
+	if (result.status !== "confirmed") return 0;
+	const replaced = replaceSetupProvider(config, result.provider);
+	await writeSetupConfig(path, result.defaultAliasTarget === void 0 ? replaced : applyDefaultAlias(replaced, result.defaultAliasTarget));
+	return 0;
+}
+function scalarOption(value, flag) {
+	if (Array.isArray(value)) throw new TypeError(`config providers update accepts ${flag} only once.`);
+	return value;
+}
+function toArray$1(value) {
+	if (value === void 0) return [];
+	return Array.isArray(value) ? value : [value];
+}
+//#endregion
 //#region src/cli/commands/config/config.ts
 const config = defineCommand({
 	children: [
@@ -500,23 +1615,25 @@ const config = defineCommand({
 		defineCommand({
 			children: [
 				ls,
-				defineCommand({
-					async action(context, providerId) {
-						const provider = (await loadMergedSetupConfig(context.io)).providers.find((item) => item.id === providerId);
-						if (provider === void 0) {
-							context.io.stderr.write(`unknown provider "${providerId}".\n`);
-							return 2;
-						}
-						context.io.stdout.write(formatProviderShow(provider));
-						return 0;
-					},
-					arguments: "<provider>",
-					description: "Show configured provider",
-					name: "show"
-				}),
-				probe
+				show,
+				probe,
+				update,
+				set,
+				unset
 			],
 			description: "Manage configured providers",
+			examples: [["# Probe and add newly reported models", "alint config providers update --provider openrouter"].join("\n"), [
+				"# Set or unset one provider header",
+				"alint config providers set --provider openrouter headers.Authorization \"Bearer $TOKEN\"",
+				"alint config providers unset --provider openrouter headers.Authorization"
+			].join("\n")],
+			help: [
+				"Inspect and edit providers in alint setup configuration.",
+				"Provider update is additive by default. It does not automatically remove a configured model merely because the remote provider no longer reports it.",
+				"Deselecting a configured model in the interactive TUI removes it when you confirm the update. Use the destructive config models prune command to remove configured models absent from provider responses.",
+				"Writes use global scope by default. Pass --local to select the current project's setup configuration.",
+				"Header values passed as command arguments may remain in shell history. Use environment-variable placeholders such as $TOKEN instead of literal secrets."
+			].join("\n\n"),
 			name: "providers"
 		})
 	],
@@ -538,9 +1655,21 @@ const config = defineCommand({
 			"# Probe an OpenAI-compatible endpoint before saving it",
 			"alint config providers probe --endpoint https://openrouter.ai/api/v1",
 			"alint config models probe --endpoint https://openrouter.ai/api/v1"
+		].join("\n"),
+		["# Probe and add newly reported provider models", "alint config providers update --provider openrouter"].join("\n"),
+		[
+			"# Remove one model or prune models missing from a provider",
+			"alint config models rm qwen --provider ollama",
+			"alint config models prune --provider ollama -N --yes"
 		].join("\n")
 	],
-	help: ["Inspect and update alint setup/configuration state.", "Use these commands to understand the effective config for a file, inspect saved provider/model setup, and probe OpenAI-compatible endpoints before using them in model-backed rules."].join("\n\n"),
+	help: [
+		"Inspect and update alint setup/configuration state.",
+		"Use these commands to understand the effective config for a file, inspect saved provider/model setup, and probe OpenAI-compatible endpoints before using them in model-backed rules.",
+		"Configuration writes use global scope by default. Pass --local to read and write the current project's .alint/config.toml instead.",
+		"Provider updates are additive by default. They do not automatically remove configured models merely because the remote provider no longer reports them.",
+		"Interactive TUI deselection can remove a configured model. Model pruning is destructive and requires confirmation."
+	].join("\n\n"),
 	name: "config"
 });
 //#endregion
@@ -582,7 +1711,7 @@ function formatStylish(input, options = {}) {
 function countCachedDiagnostics(diagnostics, severity) {
 	return diagnostics.filter((diagnostic) => diagnostic.severity === severity && diagnostic.cached === true).length;
 }
-function countDiagnostics$2(diagnostics, severity) {
+function countDiagnostics$1(diagnostics, severity) {
 	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
 }
 function createStyle(color) {
@@ -611,8 +1740,8 @@ function formatExecutionSummary(execution) {
 	return `${execution.cached}/${execution.planned} cached`;
 }
 function formatSummary(diagnostics, result, style) {
-	const warnCount = countDiagnostics$2(diagnostics, "warn");
-	const errorCount = countDiagnostics$2(diagnostics, "error");
+	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);
@@ -650,19 +1779,18 @@ function createPlainProgressReporter(options) {
 			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$1(payload.diagnostics, "warn");
-			const errorCount = countDiagnostics$1(payload.diagnostics, "error");
+			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`);
-		},
-		onRunStart: (payload) => {
-			writeLine(`alint started: ${payload.jobsTotal} queued jobs`);
 		}
 	};
 }
-function countDiagnostics$1(diagnostics, severity) {
+function countDiagnostics(diagnostics, severity) {
 	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
 }
 //#endregion
@@ -686,9 +1814,9 @@ function formatMiniBar(options) {
 			if (index <= frontierIndex) return "█";
 			return "░";
 		}
-		if (index < phase - 1) return "█";
-		if (index === phase - 1) return "░";
+		if (index < phase) return "█";
 		if (index === phase) return "▓";
+		if (index === phase + 1 && index <= frontierIndex) return "░";
 		if (index <= frontierIndex) return "█";
 		return "░";
 	}).join("")}]`;
@@ -708,35 +1836,48 @@ function createSummaryProgressReporter(options) {
 	const state = createInitialState();
 	return {
 		getRows: () => createRows(state, options, now()),
-		onDiagnostic: ({ diagnostic }) => {
-			state.diagnostics.push(diagnostic);
+		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) => {
-			const current = state.jobs.get(payload.job.id);
-			if (payload.state === "cached" && current?.state !== "cached") {
+			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.jobs.set(payload.job.id, {
-				endedAt: payload.endedAt ?? now(),
-				job: payload.job,
-				retry: current?.retry,
-				startedAt: payload.startedAt ?? current?.startedAt,
-				state: payload.state
-			});
-			transition(state.execution, "running", payload.state);
+			state.activeJobs.delete(payload.job.id);
+			state.jobTokens.delete(payload.job.id);
 		},
-		onJobQueued: ({ job }) => {
-			state.jobs.set(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"
 			});
-			state.execution.queued += 1;
 		},
 		onJobRetry: (payload) => {
-			const current = state.jobs.get(payload.job.id);
-			state.jobs.set(payload.job.id, {
+			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,
@@ -748,39 +1889,58 @@ function createSummaryProgressReporter(options) {
 			});
 		},
 		onJobStart: (payload) => {
-			state.jobs.set(payload.job.id, {
+			updateProgress(state, payload.progress);
+			state.activeJobs.set(payload.job.id, {
 				job: payload.job,
 				startedAt: payload.startedAt ?? now(),
 				state: "running"
 			});
-			transition(state.execution, "queued", "running");
-		},
-		onRunEnd: (payload) => {
-			state.diagnostics = [...payload.diagnostics];
-			state.execution = { ...payload.execution };
-			state.totalTokens = payload.usage.totalTokens;
-			state.cachedTokens = payload.usage.cached?.totalTokens ?? 0;
-			state.runStartedAt = payload.startedAt ?? state.runStartedAt;
 		},
-		onRunStart: ({ jobsTotal, startedAt }) => {
-			state.diagnostics = [];
-			state.execution = createCounts(jobsTotal);
-			state.jobs.clear();
+		onPrepareStart: ({ startedAt }) => {
+			state.activeJobs.clear();
+			state.errorCount = 0;
+			state.execution = createCounts();
+			state.progress = createProgress();
+			state.ruleGroups.clear();
 			state.runStartedAt = startedAt ?? now();
-			state.spinnerIndex = 0;
+			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, record }) => {
+		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);
-				if (state.jobs.get(job.id)?.state === "cached") state.cachedTokens += record.totalTokens;
-				else state.totalTokens += 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.spinnerIndex = (state.spinnerIndex + 1) % Math.max(options.spinnerFrames.length, 1);
+			state.animationTick += 1;
 		}
 	};
 }
@@ -806,9 +1966,6 @@ function completeGraphemeBoundary(input, maximumIndex) {
 	}
 	return boundary;
 }
-function countDiagnostics(diagnostics, severity) {
-	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
-}
 function createCounts(planned = 0) {
 	return {
 		cached: 0,
@@ -823,19 +1980,30 @@ function createCounts(planned = 0) {
 }
 function createInitialState() {
 	return {
+		activeJobs: /* @__PURE__ */ new Map(),
+		animationTick: 0,
 		cachedTokens: 0,
-		diagnostics: [],
+		errorCount: 0,
 		execution: createCounts(),
-		jobs: /* @__PURE__ */ new Map(),
 		jobTokens: /* @__PURE__ */ new Map(),
-		spinnerIndex: 0,
-		totalTokens: 0
+		progress: createProgress(),
+		ruleGroups: /* @__PURE__ */ new Map(),
+		totalTokens: 0,
+		warnCount: 0
+	};
+}
+function createProgress() {
+	return {
+		execution: createCounts(),
+		filesTotal: 0,
+		final: false,
+		jobsCompleted: 0,
+		jobsStarted: 0,
+		jobsTotal: 0
 	};
 }
 function createRows(state, options, now) {
 	if (options.rows !== void 0 && options.rows <= 0) return [];
-	const warnCount = countDiagnostics(state.diagnostics, "warn");
-	const errorCount = countDiagnostics(state.diagnostics, "error");
 	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;
@@ -845,34 +2013,27 @@ function createRows(state, options, now) {
 	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, warnCount, errorCount, options)) : visible;
+	return options.color ? visible.map((row) => styleRow(row, state, state.warnCount, state.errorCount, options)) : visible;
+}
+function createRuleGroup(job) {
+	return {
+		cached: 0,
+		cancelled: 0,
+		completed: 0,
+		failed: 0,
+		firstJobIndex: job.index,
+		planned: 0,
+		ruleId: job.ruleId,
+		skipped: 0,
+		terminalDurationMs: 0
+	};
 }
 function createRuleGroups(state) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const job of state.jobs.values()) {
-		const group = groups.get(job.job.ruleId) ?? {
-			cached: 0,
-			cancelled: 0,
-			completed: 0,
-			failed: 0,
-			firstJobIndex: job.job.index,
-			jobs: [],
-			planned: 0,
-			ruleId: job.job.ruleId,
-			skipped: 0,
-			terminalDurationMs: 0
-		};
-		group.firstJobIndex = Math.min(group.firstJobIndex, job.job.index);
-		group.jobs.push(job);
-		group.planned = Math.max(group.planned, job.job.ruleTotal);
-		if (job.state === "cached") group.cached += 1;
-		if (job.state === "cancelled") group.cancelled += 1;
-		if (job.state === "completed") group.completed += 1;
-		if (job.state === "failed") group.failed += 1;
-		if (job.state === "skipped") group.skipped += 1;
-		if (job.endedAt !== void 0 && job.startedAt !== void 0 && job.state !== "cached") group.terminalDurationMs += Math.max(job.endedAt - job.startedAt, 0);
-		groups.set(group.ruleId, group);
-	}
+	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) {
@@ -937,11 +2098,12 @@ function formatDuration(ms) {
 function formatFooters(state, options, now) {
 	const terminal = terminalCount(state.execution);
 	const elapsed = state.runStartedAt === void 0 ? 0 : now - state.runStartedAt;
-	const progressBar = formatMiniBarSegment(terminal, state.execution.planned, state.spinnerIndex, options);
-	const eta = estimateEta(elapsed, terminal, state.execution.planned);
-	const projectedTokens = terminal > 0 && state.execution.planned > 0 ? Math.ceil((state.totalTokens + state.cachedTokens) * state.execution.planned / terminal) : void 0;
+	const progressBar = state.progress.final ? formatMiniBarSegment(terminal, state.execution.planned, state.animationTick, options) : "";
+	const eta = state.progress.final ? estimateEta(elapsed, terminal, state.execution.planned) : "eta ?";
+	const projectedTokens = state.progress.final && terminal > 0 && state.execution.planned > 0 ? Math.ceil((state.totalTokens + state.cachedTokens) * state.execution.planned / terminal) : void 0;
+	const discovering = state.progress.final ? "" : " jobs (discovering)";
 	return [
-		fitRow(`${terminal}/${state.execution.planned}${progressBar} ${formatDuration(elapsed)} -> ${eta === "eta ?" ? "~?" : eta.replace("eta ", "")}`, options.columns),
+		fitRow(`${terminal}/${state.execution.planned}${discovering}${progressBar} ${formatDuration(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)
 	];
@@ -956,15 +2118,18 @@ function formatMiniBarSegment(completed, planned, tick, options) {
 	})}`;
 }
 function formatRuleRow(group, state, options) {
-	const spinner = options.spinnerFrames[state.spinnerIndex] ?? "";
+	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.spinnerIndex, options);
+	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 formatSpinnerFrame(animationTick, spinnerFrames) {
+	return spinnerFrames[animationTick % Math.max(spinnerFrames.length, 1)] ?? "";
+}
 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;
@@ -973,16 +2138,19 @@ function formatTargetRow(jobState, options, now, last) {
 }
 function styleRow(row, state, warnCount, errorCount, options) {
 	let styledRow = row;
-	const spinner = options.spinnerFrames[state.spinnerIndex] ?? "";
+	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 terminalCount(counts) {
 	return counts.completed + counts.failed + counts.cached + counts.skipped + counts.cancelled;
 }
-function transition(counts, from, to) {
-	counts[from] -= 1;
-	counts[to] += 1;
+function updateProgress(state, progress) {
+	state.execution = { ...progress.execution };
+	state.progress = {
+		...progress,
+		execution: { ...progress.execution }
+	};
 }
 //#endregion
 //#region src/cli/reporters/progress/tty.ts
@@ -1072,6 +2240,18 @@ function createRenderingProgressReporter(summary, renderer) {
 			summary.onDiagnostic?.(payload);
 			renderer.render();
 		},
+		onExecuteEnd: (payload) => {
+			summary.onExecuteEnd?.(payload);
+			renderer.render();
+		},
+		onExecuteStart: (payload) => {
+			summary.onExecuteStart?.(payload);
+			renderer.render();
+		},
+		onFileReady: (payload) => {
+			summary.onFileReady?.(payload);
+			renderer.render();
+		},
 		onJobEnd: (payload) => {
 			summary.onJobEnd?.(payload);
 			renderer.render();
@@ -1088,14 +2268,18 @@ function createRenderingProgressReporter(summary, renderer) {
 			summary.onJobStart?.(payload);
 			renderer.render();
 		},
-		onRunEnd: (payload) => {
-			summary.onRunEnd?.(payload);
+		onPrepareEnd: (payload) => {
+			summary.onPrepareEnd?.(payload);
 			renderer.render();
 		},
-		onRunStart: (payload) => {
-			summary.onRunStart?.(payload);
+		onPrepareStart: (payload) => {
+			summary.onPrepareStart?.(payload);
 			renderer.start();
 		},
+		onRunEnd: (payload) => {
+			summary.onRunEnd?.(payload);
+			renderer.render();
+		},
 		onUsage: (payload) => {
 			summary.onUsage?.(payload);
 			renderer.render();
@@ -1283,13 +2467,21 @@ function formatCancelledError(error, color) {
 }
 function formatRunError(error, color) {
 	const label = color ? colors$1.red("error") : "error";
-	const groups = groupFailuresByRule(error.failures);
+	const fileFailures = error.failures.filter((failure) => "file" in failure);
+	const groups = groupFailuresByRule(error.failures.filter((failure) => "job" in failure));
 	return [
 		`${label} ${error.message}`,
 		"",
-		`Failed Rules ${groups.length}`,
-		"",
-		...formatFailureGroups(groups, color)
+		...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) {
@@ -1298,7 +2490,7 @@ function formatFailureGroups(groups, color) {
 		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.sort((left, right) => left.job.index - right.job.index)) {
+		for (const failure of group) {
 			lines.push(`  ${formatTarget(failure)}`);
 			lines.push(`    [${failure.kind}] ${failure.message}`);
 		}
@@ -1306,6 +2498,16 @@ function formatFailureGroups(groups, color) {
 	}
 	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}`;
@@ -1741,6 +2943,9 @@ function createStatsCollector() {
 		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;
@@ -1748,9 +2953,6 @@ function createStatsCollector() {
 				counts.failed = payload.execution.failed;
 				counts.planned = payload.execution.planned;
 				endedAt = payload.endedAt;
-			},
-			onRunStart: (payload) => {
-				startedAt = payload.startedAt;
 			}
 		}
 	};
@@ -1784,6 +2986,15 @@ function mergeProgressReporters(base, extra) {
 		onDiagnostic: (payload) => {
 			deliverBoth((reporter) => reporter.onDiagnostic?.(payload));
 		},
+		onExecuteEnd: (payload) => {
+			deliverBoth((reporter) => reporter.onExecuteEnd?.(payload));
+		},
+		onExecuteStart: (payload) => {
+			deliverBoth((reporter) => reporter.onExecuteStart?.(payload));
+		},
+		onFileReady: (payload) => {
+			deliverBoth((reporter) => reporter.onFileReady?.(payload));
+		},
 		onJobEnd: (payload) => {
 			deliverBoth((reporter) => reporter.onJobEnd?.(payload));
 		},
@@ -1796,13 +3007,16 @@ function mergeProgressReporters(base, extra) {
 		onJobStart: (payload) => {
 			deliverBoth((reporter) => reporter.onJobStart?.(payload));
 		},
+		onPrepareEnd: (payload) => {
+			deliverBoth((reporter) => reporter.onPrepareEnd?.(payload));
+		},
+		onPrepareStart: (payload) => {
+			deliverBoth((reporter) => reporter.onPrepareStart?.(payload));
+		},
 		onRunEnd: (payload) => {
 			deliverBoth((reporter) => reporter.onRunEnd?.(payload));
 			if (firstFailure) throw firstFailure;
 		},
-		onRunStart: (payload) => {
-			deliverBoth((reporter) => reporter.onRunStart?.(payload));
-		},
 		onUsage: (payload) => {
 			deliverBoth((reporter) => reporter.onUsage?.(payload));
 		}
@@ -1900,6 +3114,9 @@ async function runLintCommand(files, options, io, interceptConsoleOutput) {
 	const persistStats = async (runResult) => {
 		if (statsTarget && statsCollector) await writeRunStats(statsTarget, statsCollector, runResult, io.cwd);
 	};
+	const writeResult = (runResult) => {
+		io.stdout.write(formatDiagnostics(options.format, runResult, { color: io.stdout.isTTY === true }));
+	};
 	let result;
 	try {
 		result = await runAlint({
@@ -1919,11 +3136,13 @@ async function runLintCommand(files, options, io, interceptConsoleOutput) {
 		progress?.dispose();
 		if (error instanceof AlintRunError) {
 			await persistStats(error.result);
+			writeResult(error.result);
 			io.stderr.write(formatRunError(error, io.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));
 			return 2;
 		}
@@ -1932,7 +3151,7 @@ async function runLintCommand(files, options, io, interceptConsoleOutput) {
 	restoreProgressConsole?.();
 	progress?.dispose();
 	await persistStats(result);
-	io.stdout.write(formatDiagnostics(options.format, result, { color: io.stdout.isTTY === true }));
+	writeResult(result);
 	return result.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
 }
 function shouldEnableProgress(options, io) {
@@ -2062,60 +3281,25 @@ const plugin = defineCommand({
 //#region src/cli/commands/setup/interactive.ts
 const nonTtyMessage = "interactive setup requires a TTY. Use -N/--no-interactive with --provider-id and --provider-endpoint.\n";
 const backValue = "__alint_back__";
-function applyDefaultAlias(config, target) {
-	return {
-		...config,
-		providers: config.providers.map((provider) => ({
-			...provider,
-			headers: provider.headers === void 0 ? void 0 : { ...provider.headers },
-			models: provider.models.map((model) => {
-				const aliasesWithoutDefault = (model.aliases ?? []).filter((alias) => alias !== "default");
-				const aliases = provider.id === target.providerId && model.id === target.modelId ? [...aliasesWithoutDefault, "default"] : aliasesWithoutDefault;
-				return {
-					...model,
-					aliases: aliases.length > 0 ? aliases : void 0,
-					capabilities: model.capabilities === void 0 ? void 0 : [...model.capabilities],
-					defaultParams: model.defaultParams === void 0 ? void 0 : { ...model.defaultParams }
-				};
-			})
-		}))
-	};
-}
-function createDefaultModelCandidates(config, newProviderId, newModelIds) {
-	const candidates = [];
-	const seen = /* @__PURE__ */ new Set();
-	const newModelIdSet = new Set(newModelIds);
-	const allModels = config.providers.flatMap((provider) => provider.models.map((model) => ({
-		isCurrentDefault: (model.aliases ?? []).includes("default"),
-		isNew: provider.id === newProviderId && newModelIdSet.has(model.id),
-		model,
-		provider,
-		value: createDefaultModelCandidateValue(provider.id, model.id)
-	})));
-	const addCandidate = (candidate) => {
-		if (candidate === void 0 || seen.has(candidate.value)) return;
-		seen.add(candidate.value);
-		candidates.push({
-			isCurrentDefault: candidate.isCurrentDefault,
-			isNew: candidate.isNew,
-			label: `${candidate.provider.id} / ${candidate.model.id}`,
-			modelId: candidate.model.id,
-			providerId: candidate.provider.id,
-			value: candidate.value
-		});
-	};
-	addCandidate(allModels.find((candidate) => candidate.isCurrentDefault));
-	for (const modelId of newModelIds) addCandidate(allModels.find((candidate) => candidate.provider.id === newProviderId && candidate.model.id === modelId));
-	for (const candidate of allModels) addCandidate(candidate);
-	return candidates;
-}
-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}`;
-}
-function isBackInput(value) {
-	return value.trim() === "..";
-}
+/**
+* Handles setup-only scope/source navigation and persists a confirmed provider.
+*
+* Triggering workflow:
+*
+* {@link setup}
+*   -> {@link runInteractiveSetup}
+*     -> `provider-editor.confirmed`
+*       -> {@link writeSetupConfig}
+*
+* Upstream:
+* - setup command action
+*
+* Downstream:
+* - {@link runProviderEditor} and {@link writeSetupConfig}
+*
+* The handler loads one selected scope once. Back returns to navigation,
+* cancellation writes nothing, and only a confirmed editor result is persisted.
+*/
 async function runInteractiveSetup(io) {
 	if (io.stdin?.isTTY !== true || io.stdout.isTTY !== true) {
 		io.stderr.write(nonTtyMessage);
@@ -2127,11 +3311,11 @@ async function runInteractiveSetup(io) {
 		return 1;
 	};
 	prompts.intro("alint setup");
-	const draft = {};
+	let scope = "global";
 	let step = "scope";
 	while (true) {
 		if (step === "scope") {
-			const scope = await prompts.select({
+			const selectedScope = await prompts.select({
 				message: "Where should alint write setup config?",
 				options: [{
 					label: "Global",
@@ -2141,263 +3325,50 @@ async function runInteractiveSetup(io) {
 					value: "local"
 				}]
 			});
-			if (prompts.isCancel(scope)) return cancelPrompt();
-			draft.scope = scope;
+			if (prompts.isCancel(selectedScope)) return cancelPrompt();
+			scope = selectedScope;
 			step = "source";
 			continue;
 		}
-		if (step === "source") {
-			const source = await prompts.select({
-				message: "Choose provider setup mode.",
-				options: withBackOption(providerSetupSources.map(({ label, value }) => ({
-					label,
-					value
-				})))
-			});
-			if (prompts.isCancel(source)) return cancelPrompt();
-			if (source === backValue) {
-				step = "scope";
-				continue;
-			}
-			draft.source = source;
-			step = "endpoint";
-			continue;
-		}
-		if (step === "endpoint") {
-			const setupSource = findProviderSetupSource(draft.source ?? "custom");
-			if (setupSource === void 0) return cancelPrompt();
-			const endpoint = await promptEndpoint(prompts, setupSource);
-			if (prompts.isCancel(endpoint)) return cancelPrompt();
-			if (typeof endpoint !== "string") return cancelPrompt();
-			if (isBackInput(endpoint)) {
-				step = "source";
-				continue;
-			}
-			draft.endpoint = endpoint;
-			step = "providerId";
-			continue;
-		}
-		if (step === "providerId") {
-			const existingConfig = await loadSetupConfig(getConfigPath(io, draft.scope ?? "global"));
-			const providerId = await prompts.text({
-				initialValue: draft.providerId ?? createProviderId(draft.endpoint ?? "", new Set(existingConfig.providers.map((provider) => provider.id))),
-				message: "Provider id (type .. to go back)",
-				validate: (value) => isBackInput(value ?? "") || (value ?? "").trim().length > 0 ? void 0 : "Provider id is required."
-			});
-			if (prompts.isCancel(providerId)) return cancelPrompt();
-			if (typeof providerId !== "string") return cancelPrompt();
-			if (isBackInput(providerId)) {
-				step = "endpoint";
-				continue;
-			}
-			draft.providerId = providerId;
-			step = "headers";
-			continue;
-		}
-		if (step === "headers") {
-			const headerInput = await prompts.text({
-				initialValue: draft.headerInput,
-				message: "Headers (leave empty to skip; type .. to go back)",
-				placeholder: "Authorization=Bearer token, X-Test=true",
-				validate: (value) => {
-					if (isBackInput(value ?? "")) return;
-					try {
-						parseHeaderList(splitHeaderInput(value ?? ""));
-						return;
-					} catch {
-						return "Headers must be comma-separated Key=Value entries.";
-					}
-				}
-			});
-			if (prompts.isCancel(headerInput)) return cancelPrompt();
-			if (typeof headerInput !== "string") return cancelPrompt();
-			if (isBackInput(headerInput)) {
-				step = "providerId";
-				continue;
-			}
-			draft.headerInput = headerInput;
-			draft.headers = parseHeaderList(splitHeaderInput(headerInput));
-			draft.discoveredModels = findProviderSetupSource(draft.source ?? "custom")?.probeModels === false ? [] : await probeModelsWithSpinner(prompts, draft.endpoint ?? "", draft.headers);
-			step = "models";
-			continue;
-		}
-		if (step === "models") {
-			const selectedModels = await promptModels(prompts, draft.discoveredModels ?? []);
-			if (prompts.isCancel(selectedModels)) return cancelPrompt();
-			if (selectedModels === backValue) {
-				step = "headers";
-				continue;
-			}
-			if (!Array.isArray(selectedModels)) return cancelPrompt();
-			draft.selectedModels = selectedModels;
-			step = "defaultAlias";
-			continue;
-		}
-		if (step === "defaultAlias") {
-			const defaultAliasAction = await prompts.select({
-				message: `Add alias "default" to ${draft.selectedModels?.[0]}?`,
-				options: withBackOption([
-					{
-						label: "Yes",
-						value: "yes"
-					},
-					{
-						label: "No",
-						value: "no"
-					},
-					{
-						label: "Select another",
-						value: "selectAnother"
-					}
-				])
-			});
-			if (prompts.isCancel(defaultAliasAction)) return cancelPrompt();
-			if (defaultAliasAction === backValue) {
-				step = "models";
-				continue;
-			}
-			if (defaultAliasAction === "selectAnother") {
-				step = "selectDefaultModel";
-				continue;
-			}
-			draft.defaultAliasTarget = defaultAliasAction === "yes" ? {
-				modelId: draft.selectedModels?.[0] ?? "",
-				providerId: (draft.providerId ?? "").trim()
-			} : void 0;
-			step = "confirm";
-			continue;
-		}
-		if (step === "selectDefaultModel") {
-			const existingConfig = await loadSetupConfig(getConfigPath(io, draft.scope ?? "global"));
-			const draftProvider = createProviderConfig((draft.providerId ?? "").trim(), (draft.endpoint ?? "").trim(), draft.headers, draft.selectedModels ?? []);
-			const candidates = createDefaultModelCandidates(mergeSetupConfigs(existingConfig, {
-				providers: [draftProvider],
-				version: 1
-			}), draftProvider.id, draft.selectedModels ?? []);
-			const defaultModel = await prompts.select({
-				message: "Select default model",
-				options: withBackOption(candidates.map((candidate) => ({
-					hint: candidate.isCurrentDefault ? "current default" : candidate.isNew ? "new" : void 0,
-					label: candidate.label,
-					value: candidate.value
-				})))
-			});
-			if (prompts.isCancel(defaultModel)) return cancelPrompt();
-			if (defaultModel === backValue) {
-				step = "defaultAlias";
-				continue;
-			}
-			const candidate = candidates.find((item) => item.value === defaultModel);
-			if (candidate === void 0) return cancelPrompt();
-			draft.defaultAliasTarget = {
-				modelId: candidate.modelId,
-				providerId: candidate.providerId
-			};
-			step = "confirm";
+		const selectedSource = await prompts.select({
+			message: "Choose provider setup mode.",
+			options: withBackOption(providerSetupSources.map(({ label, value }) => ({
+				label,
+				value
+			})))
+		});
+		if (prompts.isCancel(selectedSource)) return cancelPrompt();
+		if (selectedSource === backValue) {
+			step = "scope";
 			continue;
 		}
-		const nextProvider = createProviderConfig((draft.providerId ?? "").trim(), (draft.endpoint ?? "").trim(), draft.headers, draft.selectedModels ?? []);
-		const confirmed = await prompts.select({
-			message: [
-				`Write ${draft.scope} setup config?`,
-				`Provider: ${nextProvider.id}`,
-				`Endpoint: ${nextProvider.endpoint}`,
-				`Models: ${(draft.selectedModels ?? []).join(", ")}`
-			].join("\n"),
-			options: withBackOption([{
-				label: "Yes",
-				value: "yes"
-			}, {
-				label: "No",
-				value: "no"
-			}])
+		const source = findProviderSetupSource(selectedSource);
+		if (source === void 0) return cancelPrompt();
+		const configPath = getConfigPath(io, scope);
+		const existingConfig = await loadSetupConfig(configPath);
+		const result = await runProviderEditor({
+			config: existingConfig,
+			io,
+			mode: "create",
+			source
 		});
-		if (prompts.isCancel(confirmed)) return cancelPrompt();
-		if (confirmed === backValue) {
-			step = "defaultAlias";
+		if (result.status === "back") {
+			step = "source";
 			continue;
 		}
-		if (confirmed === "no") return cancelPrompt();
-		const configPath = getConfigPath(io, draft.scope ?? "global");
-		const mergedConfig = mergeSetupConfigs(await loadSetupConfig(configPath), {
-			providers: [nextProvider],
+		if (result.status === "cancelled") return cancelPrompt();
+		const merged = mergeSetupConfigs(existingConfig, {
+			providers: [result.provider],
 			version: 1
 		});
-		await writeSetupConfig(configPath, draft.defaultAliasTarget === void 0 ? mergedConfig : applyDefaultAlias(mergedConfig, draft.defaultAliasTarget));
+		await writeSetupConfig(configPath, result.defaultAliasTarget === void 0 ? merged : applyDefaultAlias(merged, result.defaultAliasTarget));
 		prompts.outro(`Wrote ${configPath}`);
 		return 0;
 	}
 }
-function withBackOption(options) {
-	return [...options, {
-		label: "Back",
-		value: backValue
-	}];
-}
-function createDefaultModelCandidateValue(providerId, modelId) {
-	return `${providerId}\u0000${modelId}`;
-}
-function createProviderConfig(providerId, endpoint, headers, modelIds) {
-	return {
-		endpoint,
-		headers,
-		id: providerId,
-		models: modelIds.map((modelId) => ({
-			id: modelId,
-			name: modelId
-		})),
-		type: "openai-compatible"
-	};
-}
 function getConfigPath(io, scope) {
 	return scope === "local" ? getProjectSetupConfigPath(io.cwd) : getGlobalSetupConfigPath(io.env ?? process.env);
 }
-async function probeModelsWithSpinner(prompts, endpoint, headers) {
-	const spinner = prompts.spinner();
-	spinner.start("Probing models");
-	try {
-		const models = await probeModels(endpoint, headers ?? {});
-		spinner.stop(models.length > 0 ? `Found ${models.length} models` : "No models discovered");
-		return models;
-	} catch (error) {
-		spinner.stop(formatProbeModelsFailure(endpoint, error));
-		return [];
-	}
-}
-async function promptEndpoint(prompts, source) {
-	return prompts.text({
-		initialValue: source.defaultEndpoint,
-		message: "Provider endpoint (type .. to go back)",
-		placeholder: source.defaultEndpoint ?? "https://example.test/v1",
-		validate: (value) => isBackInput(value ?? "") || (value ?? "").trim().length > 0 ? void 0 : "Provider endpoint is required."
-	});
-}
-async function promptModels(prompts, discoveredModels) {
-	if (discoveredModels.length > 0) {
-		const selectedModels = await prompts.multiselect({
-			message: "Select models",
-			options: withBackOption(discoveredModels.map((model) => ({
-				label: model,
-				value: model
-			}))),
-			required: true
-		});
-		return Array.isArray(selectedModels) && selectedModels.includes(backValue) ? backValue : selectedModels;
-	}
-	const modelInput = await prompts.text({
-		message: "Models",
-		placeholder: "qwen:8b, qwen:32b; type .. to go back",
-		validate: (value) => isBackInput(value ?? "") || splitModelInput(value ?? "").length > 0 ? void 0 : "At least one model is required."
-	});
-	if (prompts.isCancel(modelInput)) return modelInput;
-	return isBackInput(modelInput) ? backValue : splitModelInput(modelInput);
-}
-function splitHeaderInput(value) {
-	return value.split(",").map((item) => item.trim()).filter(Boolean);
-}
-function splitModelInput(value) {
-	return value.split(",").map((item) => item.trim()).filter(Boolean);
-}
 //#endregion
 //#region src/cli/commands/setup/index.ts
 const setup = defineCommand({