aislop 0.8.3 → 0.9.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as ENGINE_INFO, r as getEngineLabel, t as APP_VERSION } from "./version-BynHxO1X.js";
+import { n as ENGINE_INFO, r as getEngineLabel, t as APP_VERSION } from "./version-CBcgcofs.js";
 import { n as runSubprocess, t as isToolInstalled } from "./subprocess-CQUJDGgn.js";
 import { r as runGenericLinter, t as fixRubyLint } from "./generic-BrcWMW7E.js";
 import { n as runExpoDoctor } from "./expo-doctor-Bz0LZhQ6.js";
@@ -15,6 +15,7 @@ import { fileURLToPath } from "node:url";
 import { performance } from "node:perf_hooks";
 import os from "node:os";
 import ts from "typescript";
+import { randomUUID } from "node:crypto";
 import { isCancel, multiselect, select, text } from "@clack/prompts";
 
 //#region src/config/defaults.ts
@@ -27,6 +28,7 @@ const DEFAULT_CONFIG = {
 		"build",
 		"coverage"
 	],
+	include: [],
 	engines: {
 		format: true,
 		lint: true,
@@ -62,7 +64,7 @@ const DEFAULT_CONFIG = {
 		smoothing: 20
 	},
 	ci: {
-		failBelow: 0,
+		failBelow: 70,
 		format: "json"
 	},
 	telemetry: { enabled: true }
@@ -188,7 +190,7 @@ const ScoringSchema = z.object({
 	smoothing: z.number().nonnegative().default(20)
 });
 const CiSchema = z.object({
-	failBelow: z.number().default(0),
+	failBelow: z.number().default(70),
 	format: z.enum(["json"]).default("json")
 });
 const TelemetrySchema = z.object({ enabled: z.boolean().default(true) });
@@ -222,7 +224,7 @@ const AislopConfigSchema = z.object({
 		smoothing: 20
 	})),
 	ci: CiSchema.default(() => ({
-		failBelow: 0,
+		failBelow: 70,
 		format: "json"
 	})),
 	telemetry: TelemetrySchema.default(() => ({ enabled: true })),
@@ -232,7 +234,8 @@ const AislopConfigSchema = z.object({
 		"dist",
 		"build",
 		"coverage"
-	])
+	]),
+	include: z.array(z.string()).default(() => [])
 });
 const defaults = AislopConfigSchema.parse({});
 /**
@@ -560,31 +563,68 @@ const EXCLUDED_DIRS = [
 	"dist",
 	"build",
 	".git",
+	".agents",
 	"vendor",
+	"examples",
+	"example",
+	"demos",
+	"demo",
+	"bench",
+	"benches",
+	"benchmarks",
+	"fixtures",
+	"fixture",
+	"samples",
+	"sample",
+	"tutorials",
+	"tutorial",
+	"code_samples",
+	"code-samples",
+	"notebooks",
 	"tests",
 	"test",
 	"__tests__",
 	"__test__",
 	"spec",
 	"__mocks__",
-	"fixtures",
 	"test_data",
 	".next",
 	".nuxt",
 	"coverage",
-	".turbo"
+	".turbo",
+	"public"
 ];
 const FIND_PRUNE_DIRS = [
 	"node_modules",
 	"dist",
 	"build",
 	".git",
+	".agents",
 	"vendor",
+	"examples",
+	"example",
+	"demos",
+	"demo",
+	"bench",
+	"benches",
+	"benchmarks",
+	"fixtures",
+	"fixture",
+	"samples",
+	"sample",
+	"tutorials",
+	"tutorial",
+	"code_samples",
+	"code-samples",
+	"notebooks",
 	".next",
 	".nuxt",
 	"coverage",
-	".turbo"
+	".turbo",
+	"public"
 ];
+const BUILD_CACHE_FILE_PATTERNS = [/\.timestamp-\d+-[a-z0-9]+\.[mc]?js$/i];
+const isBuildCacheFile = (filePath) => BUILD_CACHE_FILE_PATTERNS.some((pattern) => pattern.test(filePath));
 const TEST_FILE_PATTERNS = [
 	/(?:^|\/).*\.test\.[^/]+$/i,
 	/(?:^|\/).*\.spec\.[^/]+$/i,
@@ -609,6 +649,7 @@ const hasAllowedExtension = (filePath, extraExtensions) => {
 	return SOURCE_EXTENSIONS.has(extension) || extraExtensions.has(extension);
 };
 const isExcludedPath = (filePath) => EXCLUDED_DIRS.some((dir) => filePath === dir || filePath.startsWith(`${dir}/`) || filePath.includes(`/${dir}/`));
+const isExcludedFromScan = (relativePath) => isExcludedPath(relativePath) || isBuildCacheFile(relativePath);
 const isTestFile$2 = (filePath) => TEST_FILE_PATTERNS.some((pattern) => pattern.test(filePath));
 const getIgnoredPaths = (rootDirectory, files) => {
 	if (files.length === 0) return /* @__PURE__ */ new Set();
@@ -667,7 +708,7 @@ const normalizeExcludePatterns = (patterns) => {
 		return [p];
 	});
 };
-const filterProjectFiles = (rootDirectory, files, extraExtensions = [], exclude = []) => {
+const filterProjectFiles = (rootDirectory, files, extraExtensions = [], exclude = [], include = []) => {
 	const extraSet = new Set(extraExtensions);
 	const normalizedFiles = files.map((file) => {
 		const absolutePath = path.isAbsolute(file) ? file : path.resolve(rootDirectory, file);
@@ -682,8 +723,16 @@ const filterProjectFiles = (rootDirectory, files, extraExtensions = [], exclude
 		if (!normalizedExcludePatterns.length) return false;
 		return micromatch.isMatch(relativePath, normalizedExcludePatterns, { dot: true });
 	};
+	const hasIncludePatterns = include.length > 0;
+	const isUserIncluded = (relativePath) => {
+		if (!hasIncludePatterns) return true;
+		return micromatch.isMatch(relativePath, include, { dot: true });
+	};
 	return normalizedFiles.filter(({ absolutePath, relativePath }) => {
-		return hasAllowedExtension(relativePath, extraSet) && !isExcludedPath(relativePath) && !isTestFile$2(relativePath) && !ignoredPaths.has(relativePath) && !isUserExcluded(relativePath) && fs.existsSync(absolutePath);
+		if (!fs.existsSync(absolutePath) || !isWithinProject(relativePath) || isExcludedPath(relativePath) || isTestFile$2(relativePath) || ignoredPaths.has(relativePath)) return false;
+		if (!isUserIncluded(relativePath)) return false;
+		if (isUserExcluded(relativePath)) return false;
+		return hasAllowedExtension(relativePath, extraSet);
 	}).map(({ absolutePath }) => absolutePath);
 };
 const filterExplicitFiles = (rootDirectory, files, extraExtensions = []) => {
@@ -1868,6 +1917,86 @@ const PYTHON_IMPORT_TO_PIP = {
 	redis: "redis"
 };
 
+//#endregion
+//#region src/engines/ai-slop/python-manifest.ts
+const addPyDep = (pyDeps, name) => {
+	const normalized = name.toLowerCase().replace(/_/g, "-");
+	pyDeps.add(normalized);
+};
+const collectFromRequirementsTxt = (rootDir, pyDeps) => {
+	const reqPath = path.join(rootDir, "requirements.txt");
+	if (!fs.existsSync(reqPath)) return false;
+	try {
+		const content = fs.readFileSync(reqPath, "utf-8");
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-")) continue;
+			const match = trimmed.match(/^([a-zA-Z0-9_\-.]+)/);
+			if (match) addPyDep(pyDeps, match[1]);
+		}
+		return true;
+	} catch {
+		return false;
+	}
+};
+const collectFromPyproject = (rootDir, pyDeps) => {
+	const pyprojPath = path.join(rootDir, "pyproject.toml");
+	if (!fs.existsSync(pyprojPath)) return false;
+	try {
+		const content = fs.readFileSync(pyprojPath, "utf-8");
+		const projectNameMatch = content.match(/\[project\][\s\S]*?^\s*name\s*=\s*["']([^"']+)/m);
+		if (projectNameMatch) addPyDep(pyDeps, projectNameMatch[1]);
+		const poetryNameMatch = content.match(/\[tool\.poetry\][\s\S]*?^\s*name\s*=\s*["']([^"']+)/m);
+		if (poetryNameMatch) addPyDep(pyDeps, poetryNameMatch[1]);
+		const pep621 = content.match(/^\s*dependencies\s*=\s*\[([\s\S]*?)\]/m);
+		if (pep621) for (const line of pep621[1].split("\n")) {
+			const m = line.match(/["']\s*([a-zA-Z0-9_\-.]+)/);
+			if (m) addPyDep(pyDeps, m[1]);
+		}
+		const poetryRe = /\[tool\.poetry(?:\.group\.[a-z]+)?\.dependencies\]([\s\S]*?)(?=\n\[|$)/g;
+		let match = poetryRe.exec(content);
+		while (match !== null) {
+			for (const line of match[1].split("\n")) {
+				const m = line.trim().match(/^([a-zA-Z0-9_\-.]+)\s*=/);
+				if (m && m[1] !== "python") addPyDep(pyDeps, m[1]);
+			}
+			match = poetryRe.exec(content);
+		}
+		return true;
+	} catch {
+		return false;
+	}
+};
+const collectFromPipfile = (rootDir, pyDeps) => {
+	const pipfilePath = path.join(rootDir, "Pipfile");
+	if (!fs.existsSync(pipfilePath)) return false;
+	try {
+		const content = fs.readFileSync(pipfilePath, "utf-8");
+		const sectionRe = /\[(packages|dev-packages)\]([\s\S]*?)(?=\n\[|$)/g;
+		let match = sectionRe.exec(content);
+		while (match !== null) {
+			for (const line of match[2].split("\n")) {
+				const m = line.trim().match(/^([a-zA-Z0-9_\-.]+)\s*=/);
+				if (m) addPyDep(pyDeps, m[1]);
+			}
+			match = sectionRe.exec(content);
+		}
+		return true;
+	} catch {
+		return false;
+	}
+};
+const collectPythonDeps = (rootDir) => {
+	const pyDeps = /* @__PURE__ */ new Set();
+	const hasReq = collectFromRequirementsTxt(rootDir, pyDeps);
+	const hasPyproject = collectFromPyproject(rootDir, pyDeps);
+	const hasPipfile = collectFromPipfile(rootDir, pyDeps);
+	return {
+		pyDeps,
+		hasPyManifest: hasReq || hasPyproject || hasPipfile
+	};
+};
+
 //#endregion
 //#region src/engines/ai-slop/hallucinated-imports.ts
 const JS_EXTENSIONS$2 = new Set([
@@ -2004,10 +2133,26 @@ const buildAliasMatcher = (key) => {
 };
 const collectAliasMatchersFromConfig = (configPath, matchers) => {
 	const opts = readJson(configPath)?.compilerOptions;
-	if (!opts || typeof opts !== "object") return;
+	if (!opts) return;
 	const paths = opts.paths;
-	if (!paths || typeof paths !== "object") return;
-	for (const key of Object.keys(paths)) matchers.push(buildAliasMatcher(key));
+	if (paths && typeof paths === "object") for (const key of Object.keys(paths)) matchers.push(buildAliasMatcher(key));
+	const baseUrl = opts.baseUrl;
+	if (typeof baseUrl === "string") {
+		const baseUrlDir = path.resolve(path.dirname(configPath), baseUrl);
+		let entries;
+		try {
+			entries = fs.readdirSync(baseUrlDir);
+		} catch {
+			return;
+		}
+		const baseSpecifiers = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			if (entry.startsWith(".") || entry === "node_modules") continue;
+			const base = entry.replace(/\.(?:[jt]sx?|mjs|cjs|d\.ts)$/i, "");
+			if (base.length > 0) baseSpecifiers.add(base);
+		}
+		for (const name of baseSpecifiers) matchers.push((spec) => spec === name || spec.startsWith(`${name}/`));
+	}
 };
 const collectTsPathAliases = (rootDir) => {
 	const matchers = [];
@@ -2015,97 +2160,35 @@ const collectTsPathAliases = (rootDir) => {
 	for (const dir of dirs) for (const fname of TS_CONFIG_FILES) collectAliasMatchersFromConfig(path.join(dir, fname), matchers);
 	return matchers;
 };
-const addPyDep = (pyDeps, name) => {
-	const normalized = name.toLowerCase().replace(/_/g, "-");
-	pyDeps.add(normalized);
-};
-const collectFromRequirementsTxt = (rootDir, pyDeps) => {
-	const reqPath = path.join(rootDir, "requirements.txt");
-	if (!fs.existsSync(reqPath)) return false;
-	try {
-		const content = fs.readFileSync(reqPath, "utf-8");
-		for (const line of content.split("\n")) {
-			const trimmed = line.trim();
-			if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-")) continue;
-			const match = trimmed.match(/^([a-zA-Z0-9_\-.]+)/);
-			if (match) addPyDep(pyDeps, match[1]);
-		}
-		return true;
-	} catch {
-		return false;
-	}
-};
-const collectFromPyproject = (rootDir, pyDeps) => {
-	const pyprojPath = path.join(rootDir, "pyproject.toml");
-	if (!fs.existsSync(pyprojPath)) return false;
-	try {
-		const content = fs.readFileSync(pyprojPath, "utf-8");
-		const projectNameMatch = content.match(/\[project\][\s\S]*?^\s*name\s*=\s*["']([^"']+)/m);
-		if (projectNameMatch) addPyDep(pyDeps, projectNameMatch[1]);
-		const poetryNameMatch = content.match(/\[tool\.poetry\][\s\S]*?^\s*name\s*=\s*["']([^"']+)/m);
-		if (poetryNameMatch) addPyDep(pyDeps, poetryNameMatch[1]);
-		const pep621 = content.match(/^\s*dependencies\s*=\s*\[([\s\S]*?)\]/m);
-		if (pep621) for (const line of pep621[1].split("\n")) {
-			const m = line.match(/["']\s*([a-zA-Z0-9_\-.]+)/);
-			if (m) addPyDep(pyDeps, m[1]);
-		}
-		const poetryRe = /\[tool\.poetry(?:\.group\.[a-z]+)?\.dependencies\]([\s\S]*?)(?=\n\[|$)/g;
-		let match = poetryRe.exec(content);
-		while (match !== null) {
-			for (const line of match[1].split("\n")) {
-				const m = line.trim().match(/^([a-zA-Z0-9_\-.]+)\s*=/);
-				if (m && m[1] !== "python") addPyDep(pyDeps, m[1]);
-			}
-			match = poetryRe.exec(content);
-		}
-		return true;
-	} catch {
-		return false;
-	}
-};
-const collectFromPipfile = (rootDir, pyDeps) => {
-	const pipfilePath = path.join(rootDir, "Pipfile");
-	if (!fs.existsSync(pipfilePath)) return false;
-	try {
-		const content = fs.readFileSync(pipfilePath, "utf-8");
-		const sectionRe = /\[(packages|dev-packages)\]([\s\S]*?)(?=\n\[|$)/g;
-		let match = sectionRe.exec(content);
-		while (match !== null) {
-			for (const line of match[2].split("\n")) {
-				const m = line.trim().match(/^([a-zA-Z0-9_\-.]+)\s*=/);
-				if (m) addPyDep(pyDeps, m[1]);
-			}
-			match = sectionRe.exec(content);
-		}
-		return true;
-	} catch {
-		return false;
-	}
-};
 const loadManifest = (rootDir) => {
 	const jsDeps = /* @__PURE__ */ new Set();
-	const pyDeps = /* @__PURE__ */ new Set();
 	const hasJsManifest = collectJsDeps(rootDir, jsDeps);
-	const hasReq = collectFromRequirementsTxt(rootDir, pyDeps);
-	const hasPyproject = collectFromPyproject(rootDir, pyDeps);
-	const hasPipfile = collectFromPipfile(rootDir, pyDeps);
+	const { pyDeps, hasPyManifest } = collectPythonDeps(rootDir);
 	return {
 		jsDeps,
 		pyDeps,
 		hasJsManifest,
-		hasPyManifest: hasReq || hasPyproject || hasPipfile
+		hasPyManifest
 	};
 };
 const isJsRelativeOrAbsolute = (spec) => spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("~/");
+const RUNTIME_BUILTINS = new Set(["bun"]);
 const isJsBuiltin = (spec) => {
+	if (RUNTIME_BUILTINS.has(spec)) return true;
 	return isBuiltin(spec.startsWith("node:") ? spec.slice(5) : spec) || isBuiltin(spec);
 };
 const VIRTUAL_MODULE_PREFIXES = [
 	"astro:",
 	"virtual:",
-	"bun:"
+	"bun:",
+	"~icons/"
 ];
 const isJsVirtualModule = (spec) => VIRTUAL_MODULE_PREFIXES.some((p) => spec.startsWith(p));
+const stripImportQuery = (spec) => {
+	const idx = spec.indexOf("?");
+	return idx === -1 ? spec : spec.slice(0, idx);
+};
+const VIRTUAL_ASSET_FILES = { "unfonts.css": "unplugin-fonts" };
 const TEMPLATE_PLACEHOLDER_RE = /\$\{/;
 const isLikelyRealImportSpec = (spec) => {
 	if (spec.length === 0) return false;
@@ -2172,10 +2255,14 @@ const extractPyImports = (content) => {
 	}
 	return results;
 };
-const checkJsImport = (spec, manifest, tsAliasMatchers) => {
+const checkJsImport = (rawSpec, manifest, tsAliasMatchers) => {
+	const spec = stripImportQuery(rawSpec);
+	if (spec.length === 0) return null;
 	if (isJsRelativeOrAbsolute(spec)) return null;
 	if (isJsBuiltin(spec)) return null;
 	if (isJsVirtualModule(spec)) return null;
+	const virtualOwner = VIRTUAL_ASSET_FILES[spec];
+	if (virtualOwner && manifest.jsDeps.has(virtualOwner)) return null;
 	if (tsAliasMatchers.some((m) => m(spec))) return null;
 	const pkg = packageNameFromImport(spec);
 	if (manifest.jsDeps.has(pkg)) return null;
@@ -3519,64 +3606,88 @@ const analyzeFunctions = (content, ext) => {
 	}
 	return functions;
 };
-const JSX_FILE_LOC_MULTIPLIER = 1.5;
+const FILE_LOC_MULTIPLIERS = {
+	".tsx": 1.5,
+	".jsx": 1.5,
+	".rs": 2.5,
+	".go": 1.5
+};
+const DECLARATION_FILE_RE = /\.d\.ts$/i;
+const fileLocBudget = (ext, relativePath, base) => {
+	if (DECLARATION_FILE_RE.test(relativePath)) return Number.POSITIVE_INFINITY;
+	const multiplier = FILE_LOC_MULTIPLIERS[ext] ?? 1;
+	return Math.ceil(base * multiplier);
+};
 const checkFileDiagnostics = (relativePath, content, limits) => {
 	const results = [];
 	const lineCount = content.split("\n").length;
 	const ext = path.extname(relativePath).toLowerCase();
 	if (isDataFile(content)) return results;
-	const configuredMax = ext === ".jsx" || ext === ".tsx" ? Math.ceil(limits.maxFileLoc * JSX_FILE_LOC_MULTIPLIER) : limits.maxFileLoc;
+	const configuredMax = fileLocBudget(ext, relativePath, limits.maxFileLoc);
+	if (!Number.isFinite(configuredMax)) return results;
 	if (lineCount > Math.ceil(configuredMax * 1.1)) results.push({
 		filePath: relativePath,
 		engine: "code-quality",
 		rule: "complexity/file-too-large",
 		severity: "warning",
-		message: `File has ${lineCount} lines (max: ${configuredMax})`,
+		message: `File too large (max: ${configuredMax})`,
 		help: "Consider splitting this file into smaller modules",
 		line: 0,
 		column: 0,
 		category: "Complexity",
-		fixable: false
+		fixable: false,
+		detail: `${lineCount} lines`
 	});
 	return results;
 };
-const checkFunctionDiagnostics = (relativePath, fn, limits) => {
+const JSX_EXTENSIONS = new Set([".tsx", ".jsx"]);
+const isComponentFunction = (name, ext) => JSX_EXTENSIONS.has(ext) && /^[A-Z]/.test(name);
+const functionLocBudget = (fn, ext, base) => {
+	if (isComponentFunction(fn.name, ext)) return Math.ceil(base * 2);
+	if (ext === ".rs") return Math.ceil(base * 1.5);
+	return base;
+};
+const checkFunctionDiagnostics = (relativePath, fn, limits, ext) => {
 	const results = [];
-	if (fn.lineCount - fn.templateLines > Math.ceil(limits.maxFunctionLoc * 1.1)) results.push({
+	const fnMax = functionLocBudget(fn, ext, limits.maxFunctionLoc);
+	if (fn.lineCount - fn.templateLines > Math.ceil(fnMax * 1.1)) results.push({
 		filePath: relativePath,
 		engine: "code-quality",
 		rule: "complexity/function-too-long",
 		severity: "warning",
-		message: `Function '${fn.name}' has ${fn.lineCount} lines (max: ${limits.maxFunctionLoc})`,
+		message: `Function too long (max: ${fnMax})`,
 		help: "Consider breaking this function into smaller pieces",
 		line: fn.startLine,
 		column: 0,
 		category: "Complexity",
-		fixable: false
+		fixable: false,
+		detail: `${fn.name} · ${fn.lineCount} lines`
 	});
 	if (fn.maxNesting > limits.maxNesting) results.push({
 		filePath: relativePath,
 		engine: "code-quality",
 		rule: "complexity/deep-nesting",
 		severity: "warning",
-		message: `Function '${fn.name}' has nesting depth ${fn.maxNesting} (max: ${limits.maxNesting})`,
+		message: `Function nested too deeply (max: ${limits.maxNesting})`,
 		help: "Consider using early returns or extracting nested logic",
 		line: fn.startLine,
 		column: 0,
 		category: "Complexity",
-		fixable: false
+		fixable: false,
+		detail: `${fn.name} · depth ${fn.maxNesting}`
 	});
 	if (fn.paramCount > limits.maxParams) results.push({
 		filePath: relativePath,
 		engine: "code-quality",
 		rule: "complexity/too-many-params",
 		severity: "warning",
-		message: `Function '${fn.name}' has ${fn.paramCount} parameters (max: ${limits.maxParams})`,
+		message: `Function has too many parameters (max: ${limits.maxParams})`,
 		help: "Consider using an options object parameter",
 		line: fn.startLine,
 		column: 0,
 		category: "Complexity",
-		fixable: false
+		fixable: false,
+		detail: `${fn.name} · ${fn.paramCount} params`
 	});
 	return results;
 };
@@ -3591,7 +3702,7 @@ const checkFileComplexity = (filePath, rootDirectory, limits) => {
 	}
 	const ext = path.extname(filePath).toLowerCase();
 	const diagnostics = checkFileDiagnostics(relativePath, content, limits);
-	for (const fn of analyzeFunctions(content, ext)) diagnostics.push(...checkFunctionDiagnostics(relativePath, fn, limits));
+	for (const fn of analyzeFunctions(content, ext)) diagnostics.push(...checkFunctionDiagnostics(relativePath, fn, limits, ext));
 	return diagnostics;
 };
 const checkComplexity = async (context) => {
@@ -3696,17 +3807,19 @@ const findDuplicateBlocks = (content, relativePath) => {
 		});
 	}
 	return reports.map((r) => {
+		const span = r.currentEnd - r.currentStart + 1;
 		return {
 			filePath: relativePath,
 			engine: "code-quality",
 			rule: "code-quality/duplicate-block",
 			severity: "warning",
-			message: `${r.currentEnd - r.currentStart + 1}-line block at line ${r.currentStart} duplicates a block starting at line ${r.priorStart}. Extract a shared helper.`,
+			message: "Duplicate code block — extract a shared helper",
 			help: `Pull the shared logic into a function both sites can call. Keeps one version of the truth and makes future changes one-shot instead of N-shot.`,
 			line: r.currentStart,
 			column: 0,
 			category: "Complexity",
-			fixable: false
+			fixable: false,
+			detail: `${span} lines duplicate block at L${r.priorStart}`
 		};
 	});
 };
@@ -4283,16 +4396,34 @@ const fixGofmt = async (rootDirectory) => {
 	if (result.exitCode !== 0) throw new Error(result.stderr || result.stdout || `gofmt exited with code ${result.exitCode}`);
 };
 
+//#endregion
+//#region src/engines/python-targets.ts
+const PYTHON_EXTENSIONS = new Set([".py", ".pyi"]);
+const normalizeProjectPath = (filePath) => filePath.split(path.sep).join("/");
+const getPythonTargets = (context) => {
+	const targets = (context.files ?? getSourceFiles(context)).filter((filePath) => PYTHON_EXTENSIONS.has(path.extname(filePath).toLowerCase())).map((filePath) => {
+		const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(context.rootDirectory, filePath);
+		return normalizeProjectPath(path.relative(context.rootDirectory, absolutePath));
+	}).filter((filePath) => filePath.length > 0 && !filePath.startsWith(".."));
+	return [...new Set(targets)];
+};
+const getRuffDiagnosticPath = (rootDirectory, filePath) => {
+	const normalizedPath = filePath.replace(/^a\//, "");
+	return normalizeProjectPath(path.isAbsolute(normalizedPath) ? path.relative(rootDirectory, normalizedPath) : normalizedPath);
+};
+
 //#endregion
 //#region src/engines/format/ruff-format.ts
 const runRuffFormat = async (context) => {
 	const ruffBinary = resolveToolBinary("ruff");
+	const targets = getPythonTargets(context);
+	if (targets.length === 0) return [];
 	try {
 		const result = await runSubprocess(ruffBinary, [
 			"format",
 			"--check",
 			"--diff",
-			context.rootDirectory
+			...targets
 		], {
 			cwd: context.rootDirectory,
 			timeout: 6e4
@@ -4308,9 +4439,9 @@ const parseRuffFormatOutput = (output, rootDir) => {
 	const filePattern = /^--- (.+)$/gm;
 	let match;
 	while ((match = filePattern.exec(output)) !== null) {
-		const filePath = match[1].replace(/^a\//, "");
+		const filePath = getRuffDiagnosticPath(rootDir, match[1]);
 		diagnostics.push({
-			filePath: path.relative(rootDir, filePath),
+			filePath,
 			engine: "format",
 			rule: "python-formatting",
 			severity: "warning",
@@ -4714,6 +4845,95 @@ const resolveOxlintBinary = () => {
 		return "oxlint";
 	}
 };
+const VITE_QUERY_RE = /["'][^"']*\?(worker|sharedworker|worker-url|url|raw|inline|init)\b/;
+const isViteVirtualImportFalsePositive = (rule, message) => rule.startsWith("import/") && VITE_QUERY_RE.test(message);
+const AMBIENT_GLOBAL_DEPS = [
+	"unplugin-icons",
+	"@types/bun",
+	"bun-types"
+];
+const SST_PLATFORM_REF_RE = /\/\/\/\s*<reference\s+path=["'][^"']*sst[\\/]+platform[\\/]+config\.d\.ts["']/;
+const ICON_AUTOIMPORT_RE = /^Icon[A-Z]/;
+const NO_UNDEF_IDENT_RE = /^['‘"`]([^'’"`]+)['’"`]/;
+const detectAmbientSources = (rootDir) => {
+	const found = /* @__PURE__ */ new Set();
+	const skipDirs = new Set([
+		"node_modules",
+		".git",
+		"dist",
+		"build",
+		"out",
+		"target",
+		"coverage",
+		".next",
+		".turbo"
+	]);
+	const walk = (dir, depth) => {
+		if (depth > 4 || found.size === AMBIENT_GLOBAL_DEPS.length) return;
+		let entries;
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (found.size === AMBIENT_GLOBAL_DEPS.length) return;
+			if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+			if (skipDirs.has(entry.name)) continue;
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) walk(full, depth + 1);
+			else if (entry.name === "package.json") try {
+				const pkg = JSON.parse(fs.readFileSync(full, "utf-8"));
+				const allDeps = {
+					...pkg.dependencies ?? {},
+					...pkg.devDependencies ?? {},
+					...pkg.peerDependencies ?? {}
+				};
+				for (const dep of AMBIENT_GLOBAL_DEPS) if (dep in allDeps) found.add(dep);
+			} catch {}
+		}
+	};
+	walk(rootDir, 0);
+	return found;
+};
+const extractNoUndefIdentifier = (message) => {
+	return NO_UNDEF_IDENT_RE.exec(message)?.[1] ?? null;
+};
+const isAmbientFalsePositive = (rule, message, sources) => {
+	if (rule !== "eslint/no-undef") return false;
+	const ident = extractNoUndefIdentifier(message);
+	if (!ident) return false;
+	if (sources.has("unplugin-icons") && ICON_AUTOIMPORT_RE.test(ident)) return true;
+	if ((sources.has("@types/bun") || sources.has("bun-types")) && ident === "Bun") return true;
+	return false;
+};
+const sstReferencedFiles = /* @__PURE__ */ new Map();
+const fileReferencesSstPlatform = (rootDir, relativeFilePath) => {
+	const cached = sstReferencedFiles.get(relativeFilePath);
+	if (cached !== void 0) return cached;
+	const absolute = path.isAbsolute(relativeFilePath) ? relativeFilePath : path.join(rootDir, relativeFilePath);
+	let referenced = false;
+	try {
+		const fd = fs.openSync(absolute, "r");
+		try {
+			const buf = Buffer.alloc(512);
+			const bytesRead = fs.readSync(fd, buf, 0, 512, 0);
+			referenced = SST_PLATFORM_REF_RE.test(buf.toString("utf-8", 0, bytesRead));
+		} finally {
+			fs.closeSync(fd);
+		}
+	} catch {
+		referenced = false;
+	}
+	sstReferencedFiles.set(relativeFilePath, referenced);
+	return referenced;
+};
+const UNUSED_VAR_IDENT_RE = /(?:Variable|Parameter|Catch parameter) '([^']+)' (?:is declared but never used|is caught but never used)/;
+const isUnderscoreUnusedVar = (rule, message) => {
+	if (rule !== "eslint/no-unused-vars") return false;
+	const match = UNUSED_VAR_IDENT_RE.exec(message);
+	return match ? match[1].startsWith("_") : false;
+};
 const parseRuleCode = (code) => {
 	if (!code) return {
 		plugin: "eslint",
@@ -4810,6 +5030,8 @@ const runOxlint = async (context) => {
 		framework: context.frameworks.find((f) => f !== "none"),
 		testFramework: detectTestFramework(context.rootDirectory)
 	});
+	const ambientSources = detectAmbientSources(context.rootDirectory);
+	sstReferencedFiles.clear();
 	try {
 		fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 		const args = [
@@ -4849,6 +5071,11 @@ const runOxlint = async (context) => {
 				fixable: false
 			};
 		}).filter((d) => {
+			if (isExcludedFromScan(path.isAbsolute(d.filePath) ? path.relative(context.rootDirectory, d.filePath) : d.filePath)) return false;
+			if (isViteVirtualImportFalsePositive(d.rule, d.message)) return false;
+			if (isAmbientFalsePositive(d.rule, d.message, ambientSources)) return false;
+			if (isUnderscoreUnusedVar(d.rule, d.message)) return false;
+			if (d.rule === "eslint/no-undef" && fileReferencesSstPlatform(context.rootDirectory, d.filePath)) return false;
 			const key = `${d.filePath}:${d.line}:${d.rule}:${d.message}`;
 			if (seen.has(key)) return false;
 			seen.add(key);
@@ -4912,18 +5139,20 @@ const fixOxlint = async (context, options = {}) => {
 //#region src/engines/lint/ruff.ts
 const runRuffLint = async (context) => {
 	const ruffBinary = resolveToolBinary("ruff");
+	const targets = getPythonTargets(context);
+	if (targets.length === 0) return [];
 	try {
 		const output = (await runSubprocess(ruffBinary, [
 			"check",
 			"--output-format=json",
-			context.rootDirectory
+			...targets
 		], {
 			cwd: context.rootDirectory,
 			timeout: 6e4
 		})).stdout;
 		if (!output) return [];
 		return JSON.parse(output).map((d) => ({
-			filePath: path.relative(context.rootDirectory, d.filename),
+			filePath: getRuffDiagnosticPath(context.rootDirectory, d.filename),
 			engine: "lint",
 			rule: `ruff/${d.code}`,
 			severity: d.code.startsWith("E") || d.code.startsWith("F") ? "error" : "warning",
@@ -5037,56 +5266,94 @@ const runPnpmAuditWithFallback = async (rootDir, timeout) => {
 		return [];
 	}
 };
+const SEVERITY_RANK = {
+	critical: 4,
+	high: 3,
+	moderate: 2,
+	low: 1
+};
 const toSeverity = (value) => value === "critical" || value === "high" ? "error" : "warning";
-const defaultAuditFixCommand = (source) => source === "pnpm audit" ? "pnpm audit --fix" : "npm audit fix";
+const upsertVuln = (bucket, packageName, severity, recommendation) => {
+	const existing = bucket.get(packageName);
+	if (existing) {
+		existing.advisories++;
+		if ((SEVERITY_RANK[severity] ?? 0) > (SEVERITY_RANK[existing.worstSeverity] ?? 0)) existing.worstSeverity = severity;
+		if (recommendation) existing.recommendations.add(recommendation);
+	} else bucket.set(packageName, {
+		packageName,
+		worstSeverity: severity,
+		advisories: 1,
+		recommendations: recommendation ? new Set([recommendation]) : /* @__PURE__ */ new Set()
+	});
+};
+const SEMVER_RE = /(\d+)\.(\d+)\.(\d+)/;
+const cmpSemver = (a, b) => {
+	const [, a1, a2, a3] = SEMVER_RE.exec(a) ?? [
+		"",
+		"0",
+		"0",
+		"0"
+	];
+	const [, b1, b2, b3] = SEMVER_RE.exec(b) ?? [
+		"",
+		"0",
+		"0",
+		"0"
+	];
+	if (Number(a1) !== Number(b1)) return Number(a1) - Number(b1);
+	if (Number(a2) !== Number(b2)) return Number(a2) - Number(b2);
+	return Number(a3) - Number(b3);
+};
+const pickBestRecommendation = (recs) => {
+	if (recs.length <= 1) return recs[0] ?? "";
+	const versioned = recs.filter((r) => SEMVER_RE.test(r));
+	if (versioned.length === 0) return recs[0];
+	return versioned.reduce((best, r) => cmpSemver(r, best) > 0 ? r : best);
+};
+const cleanRecommendation = (raw) => {
+	const t = raw.trim();
+	if (!t || t.toLowerCase() === "none") return "no fix available";
+	return t;
+};
+const aggregateToDiagnostic = (agg, source) => {
+	const best = cleanRecommendation(pickBestRecommendation([...agg.recommendations]));
+	const countLabel = agg.advisories > 1 ? ` (${agg.advisories} advisories)` : "";
+	const recLabel = best ? ` — ${best}` : "";
+	return {
+		filePath: "package.json",
+		engine: "security",
+		rule: "security/vulnerable-dependency",
+		severity: toSeverity(agg.worstSeverity),
+		message: `${agg.packageName} (${agg.worstSeverity})${recLabel}${countLabel}`,
+		help: "",
+		line: 0,
+		column: 0,
+		category: "Security",
+		fixable: false,
+		detail: source === "npm audit" ? "npm" : "pnpm"
+	};
+};
 const parseLegacyAdvisories = (advisories, source) => {
-	const diagnostics = [];
-	for (const [key, advisory] of Object.entries(advisories)) {
-		const packageName = advisory.module_name ?? advisory.name ?? advisory.package ?? key;
-		const severity = (advisory.severity ?? "moderate").toLowerCase();
-		const recommendation = advisory.recommendation ?? advisory.title ?? `Run \`${defaultAuditFixCommand(source)}\` to resolve`;
-		diagnostics.push({
-			filePath: "package.json",
-			engine: "security",
-			rule: "security/vulnerable-dependency",
-			severity: toSeverity(severity),
-			message: `Vulnerable dependency (${source}): ${packageName} (${severity})`,
-			help: withFixHint(recommendation),
-			line: 0,
-			column: 0,
-			category: "Security",
-			fixable: false
-		});
-	}
-	return diagnostics;
+	const bucket = /* @__PURE__ */ new Map();
+	for (const [key, advisory] of Object.entries(advisories)) upsertVuln(bucket, advisory.module_name ?? advisory.name ?? advisory.package ?? key, (advisory.severity ?? "moderate").toLowerCase(), advisory.recommendation ?? advisory.title ?? "");
+	return [...bucket.values()].map((agg) => aggregateToDiagnostic(agg, source));
 };
 const parseModernVulnerabilities = (vulnerabilities, source) => {
-	const diagnostics = [];
+	const bucket = /* @__PURE__ */ new Map();
 	for (const [packageName, vulnerability] of Object.entries(vulnerabilities)) {
 		const severity = (vulnerability.severity ?? "moderate").toLowerCase();
 		const fixAvailable = vulnerability.fixAvailable;
 		const isDirect = vulnerability.isDirect === true;
-		let recommendation = `Run \`${defaultAuditFixCommand(source)}\` to resolve`;
-		if (fixAvailable === false) recommendation = isDirect ? "No automatic fix — check for a newer major version" : "Transitive with no fix — add an override or upgrade the parent";
-		else if (!isDirect && fixAvailable === true) recommendation = "Transitive dep — may need an override or parent upgrade";
+		let recommendation = "";
+		if (fixAvailable === false) recommendation = isDirect ? "no automatic fix" : "transitive — needs override or parent upgrade";
+		else if (!isDirect && fixAvailable === true) recommendation = "transitive — may need override or parent upgrade";
 		else if (fixAvailable && typeof fixAvailable === "object" && "name" in fixAvailable && "version" in fixAvailable) {
 			const target = fixAvailable;
-			if (target.name && target.version) recommendation = `Upgrade to ${target.name}@${target.version}.`;
+			if (target.name && target.version) recommendation = `upgrade to ${target.name}@${target.version}`;
 		}
-		diagnostics.push({
-			filePath: "package.json",
-			engine: "security",
-			rule: "security/vulnerable-dependency",
-			severity: toSeverity(severity),
-			message: `Vulnerable dependency (${source}): ${packageName} (${severity})`,
-			help: withFixHint(recommendation),
-			line: 0,
-			column: 0,
-			category: "Security",
-			fixable: false
-		});
+		upsertVuln(bucket, packageName, severity, recommendation);
 	}
-	return diagnostics;
+	return [...bucket.values()].map((agg) => aggregateToDiagnostic(agg, source));
 };
 const parseJsAudit = (output, source) => {
 	if (!output) return [];
@@ -5874,60 +6141,348 @@ var LiveRail = class {
 };
 
 //#endregion
-//#region src/utils/telemetry.ts
-const POSTHOG_HOST = "https://eu.i.posthog.com";
-const POSTHOG_KEY = "phc_eY2cOMFva9q24GrWeOuvuVIOhCIdjOALxeAR3ItrqbJ";
-/**
-* Returns true if telemetry should be disabled.
-* Telemetry is opt-out: it runs unless explicitly disabled.
-*/
-const isTelemetryDisabled = (configEnabled) => {
-	if (process.env.AISLOP_NO_TELEMETRY === "1" || process.env.DO_NOT_TRACK === "1") return true;
-	if (process.env.CI === "true" || process.env.CI === "1") return true;
-	if (configEnabled === false) return true;
-	return false;
-};
-const getScoreBucket = (score) => {
+//#region src/telemetry/env.ts
+const detectPackageManager$1 = (env = process.env) => {
+	const execPath = env.npm_execpath ?? "";
+	if (execPath.includes("npx")) return "npx";
+	const userAgent = env.npm_config_user_agent ?? "";
+	if (userAgent.startsWith("pnpm/")) return "pnpm";
+	if (userAgent.startsWith("yarn/")) return "yarn";
+	if (userAgent.startsWith("bun/")) return "bun";
+	if (userAgent.startsWith("npm/")) return "npm";
+	if (execPath.includes("pnpm")) return "pnpm";
+	if (execPath.includes("yarn")) return "yarn";
+	if (execPath.includes("bun")) return "bun";
+	if (execPath.includes("npm")) return "npm";
+	return "unknown";
+};
+const CI_ENV_KEYS = [
+	"CI",
+	"GITHUB_ACTIONS",
+	"GITLAB_CI",
+	"CIRCLECI",
+	"TRAVIS",
+	"BUILDKITE",
+	"DRONE",
+	"TEAMCITY_VERSION",
+	"TF_BUILD"
+];
+const isCiEnv = (env = process.env) => CI_ENV_KEYS.some((k) => {
+	const v = env[k];
+	return v === "true" || v === "1" || v != null && v.length > 0 && k !== "CI";
+}) || env.CI === "true" || env.CI === "1";
+const fileCountBucket = (count) => {
+	if (count < 10) return "0-10";
+	if (count < 50) return "10-50";
+	if (count < 100) return "50-100";
+	if (count < 500) return "100-500";
+	if (count < 1e3) return "500-1000";
+	return "1000+";
+};
+const scoreBucket = (score) => {
 	if (score >= 75) return "75-100";
 	if (score >= 50) return "50-75";
 	if (score >= 25) return "25-50";
 	return "0-25";
 };
-const getAnonymousId = () => {
-	const raw = `${os.hostname()}-${os.platform()}-${os.arch()}`;
-	let hash = 5381;
-	for (let i = 0; i < raw.length; i++) hash = hash * 33 ^ raw.charCodeAt(i);
-	return `aislop_${(hash >>> 0).toString(36)}`;
+
+//#endregion
+//#region src/telemetry/identity.ts
+const FILE_BASENAME = "install_id";
+const resolveInstallIdPath = (homedir = os.homedir(), env = process.env) => {
+	if (process.platform === "linux" && env.XDG_STATE_HOME) return path.join(env.XDG_STATE_HOME, "aislop", FILE_BASENAME);
+	return path.join(homedir, ".aislop", FILE_BASENAME);
+};
+const ensureInstallId = (idPath = resolveInstallIdPath()) => {
+	if (fs.existsSync(idPath)) {
+		const existing = fs.readFileSync(idPath, "utf-8").trim();
+		if (existing.length > 0) return {
+			installId: existing,
+			created: false
+		};
+	}
+	const dir = path.dirname(idPath);
+	fs.mkdirSync(dir, { recursive: true });
+	const installId = randomUUID();
+	const tmpPath = `${idPath}.${process.pid}.tmp`;
+	fs.writeFileSync(tmpPath, `${installId}\n`, { mode: 384 });
+	try {
+		fs.renameSync(tmpPath, idPath);
+		return {
+			installId,
+			created: true
+		};
+	} catch {
+		fs.rmSync(tmpPath, { force: true });
+		return {
+			installId: fs.readFileSync(idPath, "utf-8").trim(),
+			created: false
+		};
+	}
+};
+
+//#endregion
+//#region src/telemetry/redaction.ts
+const SAFE_PROPERTY_NAMES = new Set([
+	"aislop_version",
+	"node_version",
+	"os",
+	"arch",
+	"schema_version",
+	"anonymous_install_id",
+	"package_manager",
+	"is_ci",
+	"command",
+	"language_summary",
+	"lang_typescript",
+	"lang_javascript",
+	"lang_python",
+	"lang_java",
+	"file_count_bucket",
+	"exit_code",
+	"duration_ms",
+	"error_kind",
+	"score",
+	"score_bucket",
+	"finding_count",
+	"error_count",
+	"warning_count",
+	"fixable_count",
+	"fix_steps",
+	"fix_resolved",
+	"fix_score_delta",
+	"engine_format_issues",
+	"engine_format_ms",
+	"engine_lint_issues",
+	"engine_lint_ms",
+	"engine_code_quality_issues",
+	"engine_code_quality_ms",
+	"engine_ai_slop_issues",
+	"engine_ai_slop_ms",
+	"engine_architecture_issues",
+	"engine_architecture_ms",
+	"engine_security_issues",
+	"engine_security_ms",
+	"tool",
+	"ok",
+	"agent",
+	"score_delta"
+]);
+const redactProperties = (props) => {
+	const clean = {};
+	const dropped = [];
+	for (const [key, value] of Object.entries(props)) {
+		if (value === void 0) continue;
+		if (SAFE_PROPERTY_NAMES.has(key)) clean[key] = value;
+		else dropped.push(key);
+	}
+	return {
+		clean,
+		dropped
+	};
+};
+
+//#endregion
+//#region src/telemetry/client.ts
+const POSTHOG_HOST = "https://eu.i.posthog.com";
+const POSTHOG_KEY = "phc_eY2cOMFva9q24GrWeOuvuVIOhCIdjOALxeAR3ItrqbJ";
+const SCHEMA_VERSION = "v2";
+const REQUEST_TIMEOUT_MS = 3e3;
+const isTelemetryDisabled = (config) => {
+	const env = process.env;
+	if (env.AISLOP_NO_TELEMETRY === "1" || env.DO_NOT_TRACK === "1") return true;
+	if (config?.enabled === false) return true;
+	if (config?.enabled === true) return false;
+	if (env.CI === "true" || env.CI === "1") return true;
+	return false;
 };
-/** Pending telemetry request — kept alive so Node doesn't exit before it completes. */
-let pendingRequest = null;
-const trackEvent = (event) => {
+const isDebug = () => process.env.AISLOP_TELEMETRY_DEBUG === "1";
+const pendingRequests = /* @__PURE__ */ new Set();
+let cachedInstallId = null;
+let installCreated = false;
+const baseProperties = (installId) => ({
+	aislop_version: APP_VERSION,
+	node_version: process.version,
+	os: os.platform(),
+	arch: os.arch(),
+	schema_version: SCHEMA_VERSION,
+	anonymous_install_id: installId,
+	package_manager: detectPackageManager$1(),
+	is_ci: isCiEnv()
+});
+const track = (input) => {
+	if (isTelemetryDisabled(input.config)) return { installCreated: false };
+	if (cachedInstallId == null) {
+		const ensured = ensureInstallId(resolveInstallIdPath());
+		cachedInstallId = ensured.installId;
+		installCreated = ensured.created;
+	}
+	const { clean, dropped } = redactProperties({
+		...baseProperties(cachedInstallId),
+		...input.properties
+	});
+	if (isDebug()) {
+		const compact = JSON.stringify({
+			event: input.event,
+			properties: clean
+		});
+		process.stderr.write(`[telemetry] ${compact}\n`);
+		if (dropped.length > 0) for (const key of dropped) process.stderr.write(`[telemetry] dropped non-allowlisted property: ${key}\n`);
+	}
+	if (process.env.AISLOP_TELEMETRY_DRY_RUN === "1") return { installCreated };
 	const payload = {
 		api_key: POSTHOG_KEY,
-		event: `cli_${event.command}`,
-		distinct_id: getAnonymousId(),
-		properties: {
-			version: APP_VERSION,
-			node_version: process.version,
-			os: os.platform(),
-			arch: os.arch(),
-			languages: event.languages,
-			score_bucket: event.scoreBucket,
-			engine_issues: event.engineIssues,
-			engine_timings: event.engineTimings,
-			elapsed_ms: event.elapsedMs,
-			file_count: event.fileCount,
-			fix_steps: event.fixSteps,
-			fix_resolved: event.fixResolved
-		},
+		event: input.event,
+		distinct_id: cachedInstallId,
+		properties: clean,
 		timestamp: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	pendingRequest = fetch(`${POSTHOG_HOST}/capture/`, {
+	const request = fetch(`${POSTHOG_HOST}/capture/`, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify(payload),
-		signal: AbortSignal.timeout(3e3)
-	}).then(() => {}).catch(() => {});
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+	}).then(() => {}).catch(() => {}).finally(() => {
+		pendingRequests.delete(request);
+	});
+	pendingRequests.add(request);
+	return { installCreated };
+};
+const flushTelemetry = async () => {
+	if (pendingRequests.size === 0) return;
+	await Promise.all(pendingRequests);
+};
+
+//#endregion
+//#region src/telemetry/language.ts
+const ALL_LANGUAGES = [
+	"typescript",
+	"javascript",
+	"python",
+	"java"
+];
+const buildLanguageProperties = (detected) => {
+	const present = new Set(detected);
+	const summary = [...present].filter((l) => ALL_LANGUAGES.includes(l));
+	summary.sort();
+	return {
+		language_summary: summary.join(","),
+		lang_typescript: present.has("typescript"),
+		lang_javascript: present.has("javascript"),
+		lang_python: present.has("python"),
+		lang_java: present.has("java")
+	};
+};
+
+//#endregion
+//#region src/telemetry/events.ts
+const buildCommandStartedProps = (input) => {
+	const props = { command: input.command };
+	if (input.languages) Object.assign(props, buildLanguageProperties(input.languages));
+	if (typeof input.fileCount === "number") props.file_count_bucket = fileCountBucket(input.fileCount);
+	return props;
+};
+const ENGINE_KEY_MAP = {
+	format: "engine_format",
+	lint: "engine_lint",
+	"code-quality": "engine_code_quality",
+	"ai-slop": "engine_ai_slop",
+	architecture: "engine_architecture",
+	security: "engine_security"
+};
+const flattenEngineStats = (issues, timings) => {
+	const out = {};
+	for (const [engine, count] of Object.entries(issues)) {
+		const key = ENGINE_KEY_MAP[engine];
+		if (key != null && typeof count === "number") out[`${key}_issues`] = count;
+	}
+	for (const [engine, ms] of Object.entries(timings)) {
+		const key = ENGINE_KEY_MAP[engine];
+		if (key != null && typeof ms === "number") out[`${key}_ms`] = Math.round(ms);
+	}
+	return out;
+};
+const buildCommandCompletedProps = (input) => {
+	const props = {
+		...input.startProps,
+		exit_code: input.exitCode,
+		duration_ms: Math.round(input.durationMs)
+	};
+	if (input.errorKind) props.error_kind = input.errorKind;
+	if (typeof input.score === "number") {
+		props.score = input.score;
+		props.score_bucket = scoreBucket(input.score);
+	}
+	if (typeof input.findingCount === "number") props.finding_count = input.findingCount;
+	if (typeof input.errorCount === "number") props.error_count = input.errorCount;
+	if (typeof input.warningCount === "number") props.warning_count = input.warningCount;
+	if (typeof input.fixableCount === "number") props.fixable_count = input.fixableCount;
+	if (input.engineIssues && input.engineTimings) Object.assign(props, flattenEngineStats(input.engineIssues, input.engineTimings));
+	if (typeof input.fixSteps === "number") props.fix_steps = input.fixSteps;
+	if (typeof input.fixResolved === "number") props.fix_resolved = input.fixResolved;
+	if (typeof input.fixScoreDelta === "number") props.fix_score_delta = input.fixScoreDelta;
+	return props;
+};
+const errorKindFromException = (error) => {
+	const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+	if (message.includes("timeout") || message.includes("timed out")) return "timeout";
+	if (message.includes("invalid config") || message.includes("config_invalid")) return "config_invalid";
+	if (message.includes("engine") && message.includes("crash")) return "engine_crash";
+	return "unknown";
+};
+
+//#endregion
+//#region src/telemetry/lifecycle.ts
+const withCommandLifecycle = async (start, run) => {
+	const startProps = buildCommandStartedProps({
+		command: start.command,
+		languages: start.languages,
+		fileCount: start.fileCount
+	});
+	track({
+		event: "cli_command_started",
+		properties: startProps,
+		config: start.config
+	});
+	const startedAt = performance.now();
+	try {
+		const result = await run();
+		const durationMs = performance.now() - startedAt;
+		track({
+			event: "cli_command_completed",
+			properties: buildCommandCompletedProps({
+				startProps,
+				exitCode: result.exitCode,
+				durationMs,
+				score: result.score,
+				findingCount: result.findingCount,
+				errorCount: result.errorCount,
+				warningCount: result.warningCount,
+				fixableCount: result.fixableCount,
+				engineIssues: result.engineIssues,
+				engineTimings: result.engineTimings,
+				fixSteps: result.fixSteps,
+				fixResolved: result.fixResolved,
+				fixScoreDelta: result.fixScoreDelta
+			}),
+			config: start.config
+		});
+		await flushTelemetry();
+		return result;
+	} catch (error) {
+		track({
+			event: "cli_command_completed",
+			properties: buildCommandCompletedProps({
+				startProps,
+				exitCode: 1,
+				durationMs: performance.now() - startedAt,
+				errorKind: errorKindFromException(error)
+			}),
+			config: start.config
+		});
+		await flushTelemetry();
+		throw error;
+	}
 };
 
 //#endregion
@@ -5977,8 +6532,53 @@ const wrapHelpText = (text, maxWidth, indent) => {
 };
 const terminalWidth = () => {
 	const raw = process.stdout.columns;
-	if (typeof raw !== "number" || raw <= 0) return 100;
-	return Math.min(raw, 100);
+	if (typeof raw !== "number" || raw <= 0) return 120;
+	return Math.min(raw, 120);
+};
+const renderRuleHeader = (first, count, lines) => {
+	const level = toSeverityLabel(first.severity);
+	const countLabel = count > 1 ? ` (${count})` : "";
+	const status = colorBySeverity(level, first.severity);
+	const fixableTag = first.fixable ? ` ${style(theme, "muted", "[auto]")}` : "";
+	const fixableWidth = first.fixable ? 7 : 0;
+	const badgePrefix = `    [${status}]${fixableTag} `;
+	const badgePrefixWidth = 5 + level.length + 1 + fixableWidth + 1;
+	const wrapped = wrapText(`${first.message}${countLabel}`, terminalWidth(), badgePrefixWidth, "      ");
+	lines.push(`${badgePrefix}${wrapped[0]}`);
+	for (let i = 1; i < wrapped.length; i++) lines.push(wrapped[i]);
+};
+const renderLocations = (ruleDiags, verbose, lines) => {
+	const unique = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const d of ruleDiags) {
+		const label = toLocationLabel(d);
+		const detail = d.detail ?? "";
+		const key = `${label}|${detail}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		unique.push({
+			label,
+			detail
+		});
+	}
+	const shown = verbose ? unique : unique.slice(0, 3);
+	const maxLabel = shown.reduce((w, l) => Math.max(w, l.label.length), 0);
+	for (const { label, detail } of shown) {
+		const padded = detail ? `${label.padEnd(maxLabel)}  ${detail}` : label;
+		lines.push(style(theme, "muted", `      ${padded}`));
+	}
+	if (!verbose && unique.length > shown.length) lines.push(style(theme, "muted", `      +${unique.length - shown.length} more location(s), use -d for full list`));
+};
+const renderHiddenFooter = (sorted, maxRules, lines) => {
+	const hidden = sorted.slice(maxRules);
+	const hiddenErrors = hidden.reduce((acc, [, diags]) => acc + (diags[0].severity === "error" ? diags.length : 0), 0);
+	const hiddenWarnings = hidden.reduce((acc, [, diags]) => acc + (diags[0].severity === "warning" ? diags.length : 0), 0);
+	const parts = [];
+	if (hiddenErrors > 0) parts.push(`${hiddenErrors} error${hiddenErrors === 1 ? "" : "s"}`);
+	if (hiddenWarnings > 0) parts.push(`${hiddenWarnings} warning${hiddenWarnings === 1 ? "" : "s"}`);
+	const detail = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+	lines.push(style(theme, "muted", `    ... and ${hidden.length} more rules hidden${detail}. Run with -v or --verbose to see full output.`));
+	lines.push("");
 };
 const renderDiagnostics = (diagnostics, verbose) => {
 	const lines = [];
@@ -5987,29 +6587,23 @@ const renderDiagnostics = (diagnostics, verbose) => {
 		const label = getEngineLabel(engine);
 		lines.push(`  ${style(theme, "bold", `${symbols.engineActive} ${label}`)}`);
 		const sorted = [...groupBy(engineDiags, (d) => `${d.rule}:${d.message}`).entries()].sort(([, a], [, b]) => {
-			return (a[0].severity === "error" ? 0 : a[0].severity === "warning" ? 1 : 2) - (b[0].severity === "error" ? 0 : b[0].severity === "warning" ? 1 : 2);
+			const sa = a[0].severity === "error" ? 0 : a[0].severity === "warning" ? 1 : 2;
+			const sb = b[0].severity === "error" ? 0 : b[0].severity === "warning" ? 1 : 2;
+			if (sa !== sb) return sa - sb;
+			return b.length - a.length;
 		});
-		for (const [, ruleDiags] of sorted) {
+		const maxRules = verbose ? Infinity : 40;
+		for (const [, ruleDiags] of sorted.slice(0, maxRules)) {
 			const first = ruleDiags[0];
-			const level = toSeverityLabel(first.severity);
-			const count = ruleDiags.length > 1 ? ` (${ruleDiags.length})` : "";
-			const status = colorBySeverity(level, first.severity);
-			const fixableTag = first.fixable ? ` ${style(theme, "muted", "[auto]")}` : "";
-			const fixableWidth = first.fixable ? 7 : 0;
-			const badgePrefix = `    [${status}]${fixableTag} `;
-			const badgePrefixWidth = 5 + level.length + 1 + fixableWidth + 1;
-			const wrappedMsg = wrapText(`${first.message}${count}`, terminalWidth(), badgePrefixWidth, "      ");
-			lines.push(`${badgePrefix}${wrappedMsg[0]}`);
-			for (let i = 1; i < wrappedMsg.length; i++) lines.push(wrappedMsg[i]);
-			const locations = verbose ? ruleDiags : ruleDiags.slice(0, 3);
-			for (const diagnostic of locations) lines.push(style(theme, "muted", `      ${toLocationLabel(diagnostic)}`));
-			if (!verbose && ruleDiags.length > locations.length) lines.push(style(theme, "muted", `      +${ruleDiags.length - locations.length} more location(s), use -d for full list`));
+			renderRuleHeader(first, ruleDiags.length, lines);
+			renderLocations(ruleDiags, verbose, lines);
 			if (first.help) {
 				const wrapped = wrapHelpText(first.help, terminalWidth(), "      ");
 				for (const line of wrapped) lines.push(style(theme, "muted", line));
 			}
 			lines.push("");
 		}
+		if (sorted.length > maxRules) renderHiddenFooter(sorted, maxRules, lines);
 	}
 	return `${lines.join("\n")}\n`;
 };
@@ -6147,6 +6741,81 @@ var LiveGrid = class {
 	}
 };
 
+//#endregion
+//#region src/output/rule-labels.ts
+const RULE_LABELS = {
+	formatting: "Code not formatted",
+	"code-quality/duplicate-block": "Duplicate code block",
+	"complexity/file-too-large": "File too large",
+	"complexity/function-too-long": "Function too long",
+	"complexity/deep-nesting": "Deeply nested code",
+	"complexity/too-many-params": "Too many parameters",
+	"knip/files": "Unused file",
+	"knip/dependencies": "Unused dependency",
+	"knip/devDependencies": "Unused dev dependency",
+	"knip/unlisted": "Used but not in package.json",
+	"knip/unresolved": "Unresolved import",
+	"knip/binaries": "Unused binary",
+	"knip/exports": "Unused export",
+	"knip/types": "Unused type",
+	"ai-slop/trivial-comment": "Trivial restating comment",
+	"ai-slop/swallowed-exception": "Empty catch (swallowed error)",
+	"ai-slop/thin-wrapper": "Thin function wrapper",
+	"ai-slop/generic-naming": "Generic/vague identifier name",
+	"ai-slop/unused-import": "Unused import",
+	"ai-slop/console-leftover": "console.log left in code",
+	"ai-slop/todo-stub": "Unresolved TODO/FIXME",
+	"ai-slop/unreachable-code": "Unreachable code",
+	"ai-slop/constant-condition": "Constant condition",
+	"ai-slop/empty-function": "Empty function body",
+	"ai-slop/unsafe-type-assertion": "Unsafe type cast",
+	"ai-slop/double-type-assertion": "Double type cast",
+	"ai-slop/ts-directive": "@ts-ignore / @ts-expect-error",
+	"ai-slop/narrative-comment": "Narrative comment block",
+	"ai-slop/duplicate-import": "Duplicate import statement",
+	"ai-slop/python-bare-except": "Bare except",
+	"ai-slop/python-broad-except": "Broad except",
+	"ai-slop/python-mutable-default": "Mutable default argument",
+	"ai-slop/python-print-debug": "print() left in code",
+	"ai-slop/go-library-panic": "panic() in Go library code",
+	"ai-slop/rust-non-test-unwrap": "Rust .unwrap() in production code",
+	"ai-slop/rust-todo-stub": "Rust todo!() stub",
+	"ai-slop/hallucinated-import": "Import not in package.json",
+	"security/hardcoded-secret": "Possible hardcoded secret",
+	"security/vulnerable-dependency": "Vulnerable dependency",
+	"security/eval": "eval() usage",
+	"security/innerhtml": "innerHTML assignment",
+	"security/dangerously-set-innerhtml": "dangerouslySetInnerHTML (XSS risk)",
+	"security/sql-injection": "Possible SQL injection",
+	"security/shell-injection": "Possible shell injection",
+	"eslint/no-undef": "Undefined identifier",
+	"eslint/no-unused-vars": "Unused variable",
+	"eslint/no-unassigned-vars": "Variable never assigned",
+	"eslint/no-empty": "Empty block statement",
+	"eslint/no-unused-expressions": "Unused expression",
+	"eslint/no-shadow-restricted-names": "Shadowing restricted name",
+	"eslint/no-constant-binary-expression": "Constant binary expression",
+	"eslint/no-unsafe-optional-chaining": "Unsafe optional chaining",
+	"eslint/require-yield": "Generator with no yield",
+	"import/no-duplicates": "Duplicate import path",
+	"import/default": "Missing default export",
+	"import/named": "Missing named export",
+	"import/namespace": "Invalid namespace import",
+	"typescript-eslint/triple-slash-reference": "Triple-slash reference",
+	"unicorn/no-useless-fallback-in-spread": "Useless spread fallback",
+	"unicorn/no-invalid-remove-event-listener": "Invalid removeEventListener",
+	"unicorn/no-empty-file": "Empty file",
+	"unicorn/no-useless-length-check": "Useless array length check",
+	"unicorn/no-new-array": "Avoid new Array(n)",
+	"unicorn/no-useless-spread": "Useless spread",
+	"unicorn/no-single-promise-in-promise-methods": "Single-element Promise.all"
+};
+const prettifyFallback = (ruleId) => {
+	const spaced = (ruleId.includes("/") ? ruleId.slice(ruleId.indexOf("/") + 1) : ruleId).replace(/[-_]/g, " ").replace(/\//g, " · ");
+	return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+};
+const labelForRule = (ruleId) => RULE_LABELS[ruleId] ?? prettifyFallback(ruleId);
+
 //#endregion
 //#region src/ui/summary.ts
 const elapsed = (ms) => ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(1)}s`;
@@ -6173,6 +6842,34 @@ const renderSummary = (input, deps = {}) => {
 		`   ${style(t, "muted", `${input.files} files`)}  ${sep}  ${style(t, "muted", `${input.engines} engines`)}  ${sep}  ${style(t, "muted", elapsed(input.elapsedMs))}`,
 		""
 	];
+	if (input.breakdown && input.breakdown.rows.length > 0) {
+		lines.push(` ${style(t, "bold", "Top findings")}`);
+		const maxCountWidth = input.breakdown.rows.reduce((w, r) => Math.max(w, String(r.errors + r.warnings + r.info).length), 0);
+		const labels = input.breakdown.rows.map((r) => labelForRule(r.rule));
+		const maxLabelWidth = labels.reduce((w, l) => Math.max(w, l.length), 0);
+		for (let i = 0; i < input.breakdown.rows.length; i++) {
+			const row = input.breakdown.rows[i];
+			const total = row.errors + row.warnings + row.info;
+			const count = String(total).padStart(maxCountWidth);
+			const label = padEnd(labels[i], maxLabelWidth);
+			const tags = [];
+			if (row.errors > 0) tags.push(style(t, "danger", `${row.errors} err`));
+			if (row.warnings > 0) tags.push(style(t, "warn", `${row.warnings} warn`));
+			if (row.info > 0) tags.push(style(t, "muted", `${row.info} info`));
+			if (row.fixable > 0) tags.push(style(t, "success", `${row.fixable} fix`));
+			const tagBlock = tags.length > 0 ? `  ${style(t, "muted", "·")}  ${tags.join("  ")}` : "";
+			const ruleHint = style(t, "muted", `(${row.rule})`);
+			lines.push(`   ${style(t, "muted", count)}  ${label}  ${ruleHint}${tagBlock}`);
+		}
+		if (input.breakdown.hiddenRules > 0) {
+			const hiddenParts = [];
+			if (input.breakdown.hiddenErrors > 0) hiddenParts.push(`${input.breakdown.hiddenErrors} error${input.breakdown.hiddenErrors === 1 ? "" : "s"}`);
+			if (input.breakdown.hiddenWarnings > 0) hiddenParts.push(`${input.breakdown.hiddenWarnings} warning${input.breakdown.hiddenWarnings === 1 ? "" : "s"}`);
+			const detail = hiddenParts.length > 0 ? ` (${hiddenParts.join(", ")})` : "";
+			lines.push(style(t, "muted", `   +${input.breakdown.hiddenRules} more rule${input.breakdown.hiddenRules === 1 ? "" : "s"}${detail}. Run with -v for the full list.`));
+		}
+		lines.push("");
+	}
 	if (input.nextSteps.length > 0) {
 		for (const step of input.nextSteps) {
 			const glyph = step.emphasis === "primary" ? s.hint : s.bullet;
@@ -6245,6 +6942,39 @@ const getStagedFiles = (cwd) => {
 //#region src/commands/scan.ts
 const shouldUseSpinner = () => Boolean(process.stderr.isTTY) && process.env.CI !== "true" && process.env.CI !== "1";
 const ALL_ENGINE_NAMES = Object.keys(ENGINE_INFO);
+const BREAKDOWN_TOP_N = 10;
+const computeBreakdown = (diagnostics) => {
+	const byRule = /* @__PURE__ */ new Map();
+	for (const d of diagnostics) {
+		const row = byRule.get(d.rule) ?? {
+			rule: d.rule,
+			errors: 0,
+			warnings: 0,
+			info: 0,
+			fixable: 0
+		};
+		if (d.severity === "error") row.errors++;
+		else if (d.severity === "warning") row.warnings++;
+		else row.info++;
+		if (d.fixable) row.fixable++;
+		byRule.set(d.rule, row);
+	}
+	const sorted = [...byRule.values()].sort((a, b) => {
+		const aTotal = a.errors + a.warnings + a.info;
+		const bTotal = b.errors + b.warnings + b.info;
+		if (aTotal !== bTotal) return bTotal - aTotal;
+		if (a.errors !== b.errors) return b.errors - a.errors;
+		return a.rule.localeCompare(b.rule);
+	});
+	const rows = sorted.slice(0, BREAKDOWN_TOP_N);
+	const hidden = sorted.slice(BREAKDOWN_TOP_N);
+	return {
+		rows,
+		hiddenRules: hidden.length,
+		hiddenErrors: hidden.reduce((acc, r) => acc + r.errors, 0),
+		hiddenWarnings: hidden.reduce((acc, r) => acc + r.warnings, 0)
+	};
+};
 const buildScanRender = (input) => {
 	const deps = {
 		theme: createTheme(),
@@ -6294,11 +7024,11 @@ const buildScanRender = (input) => {
 		engines: input.results.length,
 		elapsedMs: input.elapsedMs,
 		nextSteps,
+		breakdown: computeBreakdown(input.diagnostics),
 		thresholds: input.thresholds
 	}, deps)}`;
 };
 const scanCommand = async (directory, config, options) => {
-	const startTime = performance.now();
 	const resolvedDir = path.resolve(directory);
 	if (!fs.existsSync(resolvedDir)) {
 		const msg = `Path does not exist: ${resolvedDir}`;
@@ -6312,9 +7042,18 @@ const scanCommand = async (directory, config, options) => {
 		else log.error(msg);
 		return { exitCode: 1 };
 	}
+	const projectInfo = await discoverProject(resolvedDir);
+	return withCommandLifecycle({
+		command: options.command ?? "scan",
+		config: config.telemetry,
+		languages: projectInfo.languages,
+		fileCount: projectInfo.sourceFileCount
+	}, () => runScanBody(resolvedDir, config, options, projectInfo));
+};
+const runScanBody = async (resolvedDir, config, options, projectInfo) => {
+	const startTime = performance.now();
 	const showHeader = options.showHeader !== false;
 	const useLiveProgress = !options.json && shouldUseSpinner();
-	const projectInfo = await discoverProject(resolvedDir);
 	let files;
 	if (options.staged) {
 		files = filterProjectFiles(resolvedDir, getStagedFiles(resolvedDir), [], config.exclude);
@@ -6381,28 +7120,27 @@ const scanCommand = async (directory, config, options) => {
 	const elapsedMs = performance.now() - startTime;
 	const scoreResult = calculateScore(allDiagnostics, config.scoring.weights, config.scoring.thresholds, projectInfo.sourceFileCount, config.scoring.smoothing);
 	const exitCode = allDiagnostics.some((d) => d.severity === "error") || scoreResult.score < config.ci.failBelow ? 1 : 0;
-	if (!isTelemetryDisabled(config.telemetry?.enabled)) {
-		const engineIssues = {};
-		const engineTimings = {};
-		for (const r of results) {
-			engineIssues[r.engine] = r.diagnostics.length;
-			engineTimings[r.engine] = Math.round(r.elapsed);
-		}
-		trackEvent({
-			command: options.command ?? "scan",
-			languages: projectInfo.languages,
-			scoreBucket: getScoreBucket(scoreResult.score),
-			engineIssues,
-			engineTimings,
-			elapsedMs: Math.round(elapsedMs),
-			fileCount: projectInfo.sourceFileCount
-		});
-	}
+	const engineIssues = {};
+	const engineTimings = {};
+	for (const r of results) {
+		engineIssues[r.engine] = r.diagnostics.length;
+		engineTimings[r.engine] = Math.round(r.elapsed);
+	}
+	const completion = {
+		exitCode,
+		score: scoreResult.score,
+		findingCount: allDiagnostics.length,
+		errorCount: allDiagnostics.filter((d) => d.severity === "error").length,
+		warningCount: allDiagnostics.filter((d) => d.severity === "warning").length,
+		fixableCount: allDiagnostics.filter((d) => d.fixable).length,
+		engineIssues,
+		engineTimings
+	};
 	if (options.json) {
-		const { buildJsonOutput } = await import("./json-D8h2EZW6.js");
+		const { buildJsonOutput } = await import("./json-B_2_Zt7I.js");
 		const jsonOut = buildJsonOutput(results, scoreResult, projectInfo.sourceFileCount, elapsedMs);
 		console.log(JSON.stringify(jsonOut, null, 2));
-		return { exitCode };
+		return completion;
 	}
 	const projectName = projectInfo.projectName ?? "project";
 	const language = projectInfo.languages[0] ?? "unknown";
@@ -6419,7 +7157,7 @@ const scanCommand = async (directory, config, options) => {
 		includeHeader: showHeader,
 		printBrand: options.printBrand
 	}));
-	return { exitCode };
+	return completion;
 };
 
 //#endregion
@@ -7764,15 +8502,23 @@ const fixCommand = async (directory, config, options = {
 	verbose: false,
 	showHeader: true
 }) => {
-	const startTime = performance.now();
 	const resolvedDir = path.resolve(directory);
 	if (!fs.existsSync(resolvedDir) || !fs.statSync(resolvedDir).isDirectory()) {
 		const msg = !fs.existsSync(resolvedDir) ? `Path does not exist: ${resolvedDir}` : `Not a directory: ${resolvedDir}`;
 		log.error(msg);
 		return;
 	}
-	const showHeader = options.showHeader !== false;
 	const projectInfo = await discoverProject(resolvedDir);
+	await withCommandLifecycle({
+		command: "fix",
+		config: config.telemetry,
+		languages: projectInfo.languages,
+		fileCount: projectInfo.sourceFileCount
+	}, () => runFixBody(resolvedDir, config, options, projectInfo));
+};
+const runFixBody = async (resolvedDir, config, options, projectInfo) => {
+	const startTime = performance.now();
+	const showHeader = options.showHeader !== false;
 	const projectName = projectInfo.projectName ?? "project";
 	if (showHeader) process.stdout.write(renderHeader({
 		version: APP_VERSION,
@@ -7809,12 +8555,6 @@ const fixCommand = async (directory, config, options = {
 	await runFormattingStep(pipelineDeps);
 	await runForceSteps(pipelineDeps);
 	const totalResolved = steps.reduce((sum, s) => sum + s.resolvedIssues, 0);
-	if (!isTelemetryDisabled(config.telemetry?.enabled)) trackEvent({
-		command: "fix",
-		languages: projectInfo.languages,
-		fixSteps: steps.length,
-		fixResolved: totalResolved
-	});
 	const configDir = findConfigDir(resolvedDir);
 	const rulesPath = configDir ? path.join(configDir, RULES_FILE) : void 0;
 	const engineConfig = {
@@ -7837,7 +8577,9 @@ const fixCommand = async (directory, config, options = {
 	});
 	const allDiagnostics = scanResults.flatMap((r) => r.diagnostics);
 	const scoreResult = calculateScore(allDiagnostics, config.scoring.weights, config.scoring.thresholds, projectInfo.sourceFileCount, config.scoring.smoothing);
-	const remaining = allDiagnostics.filter((d) => d.severity === "error").length + allDiagnostics.filter((d) => d.severity === "warning").length;
+	const errors = allDiagnostics.filter((d) => d.severity === "error").length;
+	const warnings = allDiagnostics.filter((d) => d.severity === "warning").length;
+	const remaining = errors + warnings;
 	if (steps.length === 0) rail.complete({
 		status: "skipped",
 		label: "No applicable auto-fixers found"
@@ -7866,12 +8608,31 @@ const fixCommand = async (directory, config, options = {
 	}
 	if (options.agent) {
 		launchAgent(options.agent, resolvedDir, allDiagnostics, scoreResult.score);
-		return;
+		return {
+			exitCode: 0,
+			score: scoreResult.score,
+			fixSteps: steps.length,
+			fixResolved: totalResolved
+		};
 	}
 	if (options.prompt) {
 		printPrompt(resolvedDir, allDiagnostics, scoreResult.score);
-		return;
+		return {
+			exitCode: 0,
+			score: scoreResult.score,
+			fixSteps: steps.length,
+			fixResolved: totalResolved
+		};
 	}
+	return {
+		exitCode: 0,
+		score: scoreResult.score,
+		findingCount: allDiagnostics.length,
+		errorCount: errors,
+		warningCount: warnings,
+		fixSteps: steps.length,
+		fixResolved: totalResolved
+	};
 };
 
 //#endregion
@@ -7987,10 +8748,18 @@ const promptForConfigChoices = async () => {
 	return {
 		engines: enginesSelection,
 		failBelow: Number(failBelowRaw),
+		typecheck: DEFAULT_CONFIG.lint.typecheck,
 		telemetryEnabled: telemetryChoice === "enabled",
 		writeGithubWorkflow: workflowChoice === "yes"
 	};
 };
+const strictChoices = () => ({
+	engines: Object.keys(DEFAULT_CONFIG.engines),
+	failBelow: 85,
+	typecheck: true,
+	telemetryEnabled: DEFAULT_CONFIG.telemetry.enabled,
+	writeGithubWorkflow: true
+});
 const writeAislopConfig = (configDir, configPath, choices) => {
 	const selected = new Set(choices.engines);
 	const engines = {
@@ -8005,6 +8774,7 @@ const writeAislopConfig = (configDir, configPath, choices) => {
 		version: DEFAULT_CONFIG.version,
 		engines,
 		quality: { ...DEFAULT_CONFIG.quality },
+		lint: { typecheck: choices.typecheck },
 		security: { ...DEFAULT_CONFIG.security },
 		scoring: {
 			weights: { ...DEFAULT_CONFIG.scoring.weights },
@@ -8057,7 +8827,7 @@ const initCommand = async (directory, options = {}) => {
 			return;
 		}
 	}
-	const choices = await promptForConfigChoices();
+	const choices = options.strict ? strictChoices() : await promptForConfigChoices();
 	if (!choices) return;
 	writeAislopConfig(configDir, configPath, choices);
 	const steps = [{