aislop 0.6.2 → 0.8.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
+import { createRequire, isBuiltin } from "node:module";
 import { Command } from "commander";
 import os from "node:os";
 import fs from "node:fs";
@@ -7,7 +7,7 @@ import path from "node:path";
 import YAML from "yaml";
 import { z } from "zod/v4";
 import { performance } from "node:perf_hooks";
-import { spawn, spawnSync } from "node:child_process";
+import { execSync, spawn, spawnSync } from "node:child_process";
 import micromatch from "micromatch";
 import { fileURLToPath } from "node:url";
 import ts from "typescript";
@@ -34,7 +34,11 @@ var __exportAll = (all, no_symbols) => {
 
 //#endregion
 //#region src/hooks/feedback.ts
+const fingerprintFinding = (f) => `${f.file}:${f.line}:${f.ruleId}`;
 const MAX_FINDINGS = 20;
+const MAX_NEW_SINCE_BASELINE = 10;
+const REVIEW_TOP_N = 3;
+const REGRESSION_FLAG_THRESHOLD = 5;
 const toFinding = (d, rootDirectory) => {
 	if (d.severity !== "error" && d.severity !== "warning") return null;
 	const file = path.isAbsolute(d.filePath) ? path.relative(rootDirectory, d.filePath) : d.filePath;
@@ -64,6 +68,42 @@ const buildNextSteps = (findings) => {
 	}
 	return steps;
 };
+const buildSuggestedActions = (diagnostics, findings, regressed, delta) => {
+	const actions = [];
+	const fixableDiags = diagnostics.filter((d) => d.fixable);
+	if (fixableDiags.length > 0) {
+		const ruleIds = Array.from(new Set(fixableDiags.map((d) => d.rule)));
+		actions.push({
+			id: "run_aislop_fix",
+			label: `Run aislop fix to clear ${fixableDiags.length} mechanical finding${fixableDiags.length === 1 ? "" : "s"}.`,
+			command: "npx aislop fix",
+			rationale: "These findings have deterministic fixes (formatting, unused imports, trivial comments). Running this before any manual work avoids burning agent tokens on what the CLI handles for free.",
+			ruleIds
+		});
+	}
+	const archErrors = findings.filter((f) => f.ruleId.startsWith("arch/") && f.severity === "error");
+	if (archErrors.length > 0) actions.push({
+		id: "review_finding",
+		label: `Review ${archErrors.length} architecture rule violation${archErrors.length === 1 ? "" : "s"} — these can't be auto-fixed.`,
+		rationale: "Architecture rules encode intentional project structure decisions. The fix usually means moving code, not editing it.",
+		ruleIds: Array.from(new Set(archErrors.map((f) => f.ruleId)))
+	});
+	if (regressed && typeof delta === "number" && delta <= -REGRESSION_FLAG_THRESHOLD && fixableDiags.length === 0) {
+		const top = findings.filter((f) => f.severity === "error" || f.severity === "warning").slice(0, REVIEW_TOP_N);
+		if (top.length > 0) actions.push({
+			id: "review_finding",
+			label: `Score dropped ${Math.abs(delta)} points — review the top ${top.length} finding${top.length === 1 ? "" : "s"} from this edit.`,
+			rationale: "None of these are auto-fixable. Read each one against the source and decide whether the fix is to change the code or to add a justified suppression with a reason.",
+			ruleIds: top.map((f) => f.ruleId)
+		});
+	}
+	if (actions.length === 0) actions.push({
+		id: "no_action",
+		label: typeof delta === "number" ? delta > 0 ? `Score improved by ${delta}. No action needed.` : "Score unchanged. No action needed." : "No findings. No action needed.",
+		rationale: "The current scan didn't reveal anything that requires the agent's attention."
+	});
+	return actions;
+};
 const buildFeedback = (diagnostics, score, rootDirectory, baseline) => {
 	const all = diagnostics.map((d) => toFinding(d, rootDirectory)).filter((x) => x !== null);
 	const capped = all.slice(0, MAX_FINDINGS);
@@ -74,15 +114,30 @@ const buildFeedback = (diagnostics, score, rootDirectory, baseline) => {
 		fixable: diagnostics.filter((d) => d.fixable).length,
 		total: all.length
 	};
+	const baselineSnapshot = typeof baseline === "number" ? {
+		score: baseline,
+		findingFingerprints: []
+	} : baseline;
+	const baselineScore = baselineSnapshot?.score;
+	const delta = typeof baselineScore === "number" ? score - baselineScore : void 0;
+	const regressed = typeof delta === "number" ? delta < 0 : false;
+	let newSinceBaseline;
+	if (baselineSnapshot && baselineSnapshot.findingFingerprints.length > 0) {
+		const known = new Set(baselineSnapshot.findingFingerprints);
+		newSinceBaseline = all.filter((f) => !known.has(fingerprintFinding(f))).slice(0, MAX_NEW_SINCE_BASELINE);
+	}
 	return {
-		schema: "aislop.hook.v1",
+		schema: "aislop.hook.v2",
 		score,
-		baseline,
-		regressed: typeof baseline === "number" ? score < baseline : false,
+		baseline: baselineScore,
+		delta,
+		regressed,
 		counts,
 		findings: capped,
 		elided,
-		nextSteps: buildNextSteps(capped)
+		newSinceBaseline,
+		nextSteps: buildNextSteps(capped),
+		suggestedActions: buildSuggestedActions(diagnostics, capped, regressed, delta)
 	};
 };
 
@@ -147,6 +202,7 @@ const DEFAULT_CONFIG = {
 		maxNesting: 5,
 		maxParams: 6
 	},
+	lint: { typecheck: false },
 	security: {
 		audit: true,
 		auditTimeout: 25e3
@@ -209,6 +265,48 @@ const DEFAULT_RULES_YAML = `# Architecture rules (BYO)
 #     severity: error
 `;
 
+//#endregion
+//#region src/config/extends.ts
+const MAX_DEPTH = 5;
+const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const deepMerge = (...sources) => {
+	const result = {};
+	for (const source of sources) for (const key of Object.keys(source)) {
+		const a = result[key];
+		const b = source[key];
+		result[key] = isPlainObject(a) && isPlainObject(b) ? deepMerge(a, b) : b;
+	}
+	return result;
+};
+const resolveExtendsRef = (ref, fromDir) => {
+	if (ref.startsWith("http://") || ref.startsWith("https://")) throw new Error(`URL-based extends not yet supported: ${ref}`);
+	if (ref.startsWith("./") || ref.startsWith("../") || path.isAbsolute(ref)) return path.resolve(fromDir, ref);
+	throw new Error(`Package-name extends not yet supported: ${ref} (use a relative path for now)`);
+};
+const normalizeExtends = (raw) => {
+	if (raw === void 0 || raw === null) return [];
+	if (typeof raw === "string") return [raw];
+	if (Array.isArray(raw) && raw.every((s) => typeof s === "string")) return raw;
+	throw new Error("`extends` must be a string or array of strings");
+};
+const loadConfigChain = (configPath, visited = /* @__PURE__ */ new Set(), depth = 0) => {
+	if (depth > MAX_DEPTH) throw new Error(`extends depth exceeded ${MAX_DEPTH} (cycle or runaway chain): ${configPath}`);
+	const absPath = path.resolve(configPath);
+	if (visited.has(absPath)) throw new Error(`circular extends detected: ${absPath}`);
+	if (!fs.existsSync(absPath)) throw new Error(`extends target not found: ${absPath}`);
+	const nextVisited = new Set(visited);
+	nextVisited.add(absPath);
+	const raw = fs.readFileSync(absPath, "utf-8");
+	const parsed = YAML.parse(raw) ?? {};
+	const refs = normalizeExtends(parsed.extends);
+	const fromDir = path.dirname(absPath);
+	const parents = refs.map((ref) => {
+		return loadConfigChain(resolveExtendsRef(ref, fromDir), nextVisited, depth + 1);
+	});
+	const { extends: _drop, ...own } = parsed;
+	return deepMerge(...parents, own);
+};
+
 //#endregion
 //#region src/config/schema.ts
 const DEFAULT_WEIGHTS = {
@@ -233,6 +331,7 @@ const QualitySchema = z.object({
 	maxNesting: z.number().positive().default(5),
 	maxParams: z.number().positive().default(6)
 });
+const LintConfigSchema = z.object({ typecheck: z.boolean().default(false) });
 const SecurityConfigSchema = z.object({
 	audit: z.boolean().default(true),
 	auditTimeout: z.number().positive().default(25e3)
@@ -270,6 +369,7 @@ const AislopConfigSchema = z.object({
 		maxNesting: 5,
 		maxParams: 6
 	})),
+	lint: LintConfigSchema.default(() => ({ typecheck: false })),
 	security: SecurityConfigSchema.default(() => ({
 		audit: true,
 		auditTimeout: 25e3
@@ -343,8 +443,7 @@ const loadConfig = (directory) => {
 	const configPath = path.join(configDir, CONFIG_FILE);
 	if (!fs.existsSync(configPath)) return DEFAULT_CONFIG;
 	try {
-		const raw = fs.readFileSync(configPath, "utf-8");
-		return parseConfig(YAML.parse(raw));
+		return parseConfig(loadConfigChain(configPath));
 	} catch (error) {
 		const msg = error instanceof Error ? error.message : String(error);
 		process.stderr.write(`  ⚠ Failed to parse ${configPath}: ${msg}\n  ⚠ Using default configuration.\n`);
@@ -423,7 +522,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 isTestFile = (filePath) => TEST_FILE_PATTERNS.some((pattern) => pattern.test(filePath));
+const isTestFile$2 = (filePath) => TEST_FILE_PATTERNS.some((pattern) => pattern.test(filePath));
 const getIgnoredPaths = (rootDirectory, files) => {
 	if (files.length === 0) return /* @__PURE__ */ new Set();
 	const result = spawnSync("git", [
@@ -497,7 +596,7 @@ const filterProjectFiles = (rootDirectory, files, extraExtensions = [], exclude
 		return micromatch.isMatch(relativePath, normalizedExcludePatterns, { dot: true });
 	};
 	return normalizedFiles.filter(({ absolutePath, relativePath }) => {
-		return hasAllowedExtension(relativePath, extraSet) && !isExcludedPath(relativePath) && !isTestFile(relativePath) && !ignoredPaths.has(relativePath) && !isUserExcluded(relativePath) && fs.existsSync(absolutePath);
+		return hasAllowedExtension(relativePath, extraSet) && !isExcludedPath(relativePath) && !isTestFile$2(relativePath) && !ignoredPaths.has(relativePath) && !isUserExcluded(relativePath) && fs.existsSync(absolutePath);
 	}).map(({ absolutePath }) => absolutePath);
 };
 const filterExplicitFiles = (rootDirectory, files, extraExtensions = []) => {
@@ -633,13 +732,14 @@ const detectOverAbstraction = async (context) => {
 
 //#endregion
 //#region src/engines/ai-slop/comments.ts
+const NON_PRODUCTION_DIR_PATTERN$2 = /(?:^|\/)(?:scripts|bin|examples?|demos?|bench|benches|benchmarks?|fixtures?|__fixtures__|__mocks__|__tests__|vendor|_vendor|vendored|third_party|blib2to3|lib2to3)\//i;
 const TRIVIAL_VERB_STEMS = "Import|Defin|Initializ|Setting|Set\\s+up|Setup|Return|Check|Loop|Iterat|Creat|Updat|Delet|Remov|Handl|Get|Fetch|Increment|Decrement|Writ|Runn|Run|Pars|Execut|Extract|Sav|Load|Build|Start|Stopp|Stop|Clean(?:up|\\s+up)?|Configur|Validat|Process|Queue|Fire|Emit|Dispatch|Log|Print|Render";
 const TRIVIAL_JS_COMMENT_PATTERNS = [/\/\/\s*This (?:function|method|class|variable|constant) (?:will |is used to |is responsible for )?/i, new RegExp(`\\/\\/\\s*(?:${TRIVIAL_VERB_STEMS})(?:e|es|ing|s)?\\b`, "i")];
 const TRIVIAL_PYTHON_COMMENT_PATTERNS = [/^#\s*This (?:function|method|class) (?:will |is used to )?/i, new RegExp(`^#\\s*(?:${TRIVIAL_VERB_STEMS})(?:e|es|ing|s)?\\b`, "i")];
 const EXPLANATORY_KEYWORDS = /\b(?:because|since|note|todo|fixme|hack|warn|warning|workaround|caveat|important|assumes?)\b/i;
 const COMMENTED_CODE_CHARS = /[({=;}\]>]/;
 const MAX_TRIVIAL_COMMENT_LENGTH = 60;
-const isJsComment = (trimmed) => trimmed.startsWith("//");
+const isJsComment = (trimmed) => trimmed.startsWith("//") && !trimmed.startsWith("///") && !trimmed.startsWith("//!");
 const isPythonComment = (trimmed) => trimmed.startsWith("#") && !trimmed.startsWith("#!");
 /**
 * Extract just the comment text after the comment marker.
@@ -688,13 +788,14 @@ const detectTrivialComments = async (context) => {
 	const diagnostics = [];
 	for (const filePath of files) {
 		if (isAutoGenerated(filePath)) continue;
+		const relativePath = path.relative(context.rootDirectory, filePath);
+		if (NON_PRODUCTION_DIR_PATTERN$2.test(relativePath)) continue;
 		let content;
 		try {
 			content = fs.readFileSync(filePath, "utf-8");
 		} catch {
 			continue;
 		}
-		const relativePath = path.relative(context.rootDirectory, filePath);
 		diagnostics.push(...scanFileForTrivialComments(content, relativePath));
 	}
 	return diagnostics;
@@ -702,7 +803,7 @@ const detectTrivialComments = async (context) => {
 
 //#endregion
 //#region src/engines/ai-slop/dead-patterns.ts
-const JS_EXTENSIONS$1 = new Set([
+const JS_EXTENSIONS$4 = new Set([
 	".ts",
 	".tsx",
 	".js",
@@ -724,11 +825,11 @@ const slop = (filePath, line, rule, severity, message, help, fixable) => ({
 	fixable
 });
 const LOGGER_FILE_PATTERN = /(?:^|\/)(?:logger|logging|log)\.[^/]+$/i;
-const SCRIPT_DIR_PATTERN = /(?:^|\/)(scripts|bin)\//;
+const NON_PRODUCTION_DIR_PATTERN$1 = /(?:^|\/)(?:scripts|bin|examples?|demos?|bench|benches|benchmarks?|fixtures?|__fixtures__|__mocks__|__tests__|cli|cli-[\w-]+|[\w-]+-cli)\//;
 const detectConsoleLeftovers = (content, relativePath, ext) => {
-	if (!JS_EXTENSIONS$1.has(ext)) return [];
+	if (!JS_EXTENSIONS$4.has(ext)) return [];
 	if (LOGGER_FILE_PATTERN.test(relativePath)) return [];
-	if (SCRIPT_DIR_PATTERN.test(relativePath)) return [];
+	if (NON_PRODUCTION_DIR_PATTERN$1.test(relativePath)) return [];
 	const diagnostics = [];
 	const lines = content.split("\n");
 	for (let i = 0; i < lines.length; i++) {
@@ -768,9 +869,9 @@ const detectDeadCodePatterns = (content, relativePath, ext) => {
 	for (let i = 0; i < lines.length; i++) {
 		const trimmed = lines[i].trim();
 		const nextLine = i + 1 < lines.length ? lines[i + 1]?.trim() : void 0;
-		if (JS_EXTENSIONS$1.has(ext) && /^(?:return|throw)\b/.test(trimmed) && trimmed.endsWith(";") && nextLine && nextLine.length > 0 && !nextLine.startsWith("}") && !nextLine.startsWith("//") && !nextLine.startsWith("/*") && !nextLine.startsWith("case ") && !nextLine.startsWith("default:") && !nextLine.startsWith("if ") && !nextLine.startsWith("if(") && !nextLine.startsWith("else")) diagnostics.push(slop(relativePath, i + 2, "ai-slop/unreachable-code", "warning", "Code after return/throw statement is unreachable", "Remove the unreachable code or restructure the control flow", false));
+		if (JS_EXTENSIONS$4.has(ext) && /^(?:return|throw)\b/.test(trimmed) && trimmed.endsWith(";") && nextLine && nextLine.length > 0 && !nextLine.startsWith("}") && !nextLine.startsWith("//") && !nextLine.startsWith("/*") && !nextLine.startsWith("case ") && !nextLine.startsWith("default:") && !nextLine.startsWith("if ") && !nextLine.startsWith("if(") && !nextLine.startsWith("else")) diagnostics.push(slop(relativePath, i + 2, "ai-slop/unreachable-code", "warning", "Code after return/throw statement is unreachable", "Remove the unreachable code or restructure the control flow", false));
 		if (/\bif\s*\(\s*(?:false|true|0|1)\s*\)/.test(trimmed) && !trimmed.startsWith("//") && !trimmed.startsWith("*") && !/["'`].*\bif\s*\(/.test(trimmed) && !/\/.*\bif\s*\(/.test(trimmed.replace(/\/\/.*$/, ""))) diagnostics.push(slop(relativePath, i + 1, "ai-slop/constant-condition", "warning", "Conditional with a constant value — likely debugging leftover", "Remove the constant condition or replace with proper logic", false));
-		if (JS_EXTENSIONS$1.has(ext) && /(?:function\s+\w+|=>\s*)\s*\{\s*\}\s*;?\s*$/.test(trimmed) && !trimmed.startsWith("interface") && !trimmed.startsWith("type ")) diagnostics.push(slop(relativePath, i + 1, "ai-slop/empty-function", "info", "Empty function body — possible stub or unfinished implementation", "Implement the function body or add a comment explaining why it's empty", false));
+		if (JS_EXTENSIONS$4.has(ext) && /(?:function\s+\w+|=>\s*)\s*\{\s*\}\s*;?\s*$/.test(trimmed) && !trimmed.startsWith("interface") && !trimmed.startsWith("type ")) diagnostics.push(slop(relativePath, i + 1, "ai-slop/empty-function", "info", "Empty function body — possible stub or unfinished implementation", "Implement the function body or add a comment explaining why it's empty", false));
 	}
 	return diagnostics;
 };
@@ -778,6 +879,7 @@ const asAnyPattern = new RegExp(`\\bas\\s+any\\b`);
 const doubleAssertPattern = new RegExp(`\\bas\\s+unknown\\s+as\\s+`);
 const detectUnsafeTypePatterns = (content, relativePath, ext) => {
 	if (ext !== ".ts" && ext !== ".tsx") return [];
+	if (NON_PRODUCTION_DIR_PATTERN$1.test(relativePath)) return [];
 	const diagnostics = [];
 	const lines = content.split("\n");
 	for (let i = 0; i < lines.length; i++) {
@@ -814,6 +916,74 @@ const detectDeadPatterns = async (context) => {
 	return diagnostics;
 };
 
+//#endregion
+//#region src/engines/ai-slop/duplicate-imports.ts
+const JS_EXTENSIONS$3 = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const IMPORT_FROM_RE$1 = /^\s*import\s+[^;]*?from\s+["']([^"']+)["']/;
+const extractImportLines = (content) => {
+	const lines = content.split("\n");
+	const results = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const match = IMPORT_FROM_RE$1.exec(line);
+		if (!match) continue;
+		results.push({
+			spec: match[1],
+			line: i + 1
+		});
+	}
+	return results;
+};
+const detectDuplicateImports = async (context) => {
+	const diagnostics = [];
+	const files = getSourceFiles(context);
+	for (const filePath of files) {
+		if (!JS_EXTENSIONS$3.has(path.extname(filePath))) continue;
+		if (isAutoGenerated(filePath)) continue;
+		let content;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const imports = extractImportLines(content);
+		if (imports.length < 2) continue;
+		const bySpec = /* @__PURE__ */ new Map();
+		for (const imp of imports) {
+			const list = bySpec.get(imp.spec) ?? [];
+			list.push(imp);
+			bySpec.set(imp.spec, list);
+		}
+		const relPath = path.relative(context.rootDirectory, filePath);
+		for (const [spec, occurrences] of bySpec) {
+			if (occurrences.length < 2) continue;
+			for (const dup of occurrences.slice(1)) {
+				const firstLine = occurrences[0].line;
+				diagnostics.push({
+					filePath: relPath,
+					engine: "ai-slop",
+					rule: "ai-slop/duplicate-import",
+					severity: "warning",
+					message: `"${spec}" is also imported on line ${firstLine}. Merge into a single import statement.`,
+					help: "Two imports from the same module split readers' attention and grow the import block. Run aislop fix to merge them automatically.",
+					line: dup.line,
+					column: 1,
+					category: "AI Slop",
+					fixable: true
+				});
+			}
+		}
+	}
+	return diagnostics;
+};
+
 //#endregion
 //#region src/engines/ai-slop/exceptions.ts
 const SWALLOWED_EXCEPTION_PATTERNS = [
@@ -904,6 +1074,600 @@ const detectSwallowedExceptions = async (context) => {
 	return diagnostics;
 };
 
+//#endregion
+//#region src/engines/ai-slop/go-patterns.ts
+const GO_EXTENSIONS = new Set([".go"]);
+const PACKAGE_DECL_RE = /^\s*package\s+(\w+)/;
+const PANIC_CALL_RE = /\bpanic\s*\(/;
+const COMMENT_LINE_RE$1 = /^\s*\/\//;
+const NIL_GUARD_RE = /^\s*if\s+[\w.]+(?:\(\))?\s*==\s*nil\s*\{?\s*$/;
+const SHORT_STRING_PANIC_RE = /\bpanic\s*\(\s*"[^"]{1,40}"\s*\)/;
+const detectPackageName = (lines) => {
+	for (const line of lines) {
+		const m = PACKAGE_DECL_RE.exec(line);
+		if (m) return m[1];
+	}
+	return null;
+};
+const PANIC_INTENT_LOOKBACK = 3;
+const hasIntentComment$1 = (lines, panicLineIdx) => {
+	for (let j = panicLineIdx - 1; j >= Math.max(0, panicLineIdx - PANIC_INTENT_LOOKBACK); j--) if (COMMENT_LINE_RE$1.test(lines[j])) return true;
+	return false;
+};
+const isNilGuardPanic = (lines, panicLineIdx, line) => {
+	if (!SHORT_STRING_PANIC_RE.test(line)) return false;
+	for (let j = panicLineIdx - 1; j >= Math.max(0, panicLineIdx - 2); j--) {
+		const prev = lines[j];
+		if (prev.trim() === "") continue;
+		return NIL_GUARD_RE.test(prev);
+	}
+	return false;
+};
+const flagLibraryPanic = (lines, relPath, pkg, out) => {
+	if (pkg === "main") return;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (COMMENT_LINE_RE$1.test(line)) continue;
+		PANIC_CALL_RE.lastIndex = 0;
+		if (!PANIC_CALL_RE.test(line)) continue;
+		if (hasIntentComment$1(lines, i)) continue;
+		if (isNilGuardPanic(lines, i, line)) continue;
+		out.push({
+			filePath: relPath,
+			engine: "ai-slop",
+			rule: "ai-slop/go-library-panic",
+			severity: "warning",
+			message: `\`panic()\` in package \`${pkg}\` (non-main, non-test). Library code should return errors, not unwind the goroutine.`,
+			help: "Convert to `return fmt.Errorf(...)` (or a wrapped error) and let the caller decide. Reserve `panic` for genuinely-impossible states (corrupt internal invariants), and mark those with a comment so future readers know it's intentional.",
+			line: i + 1,
+			column: 1,
+			category: "AI Slop",
+			fixable: false
+		});
+	}
+};
+const detectGoPatterns = async (context) => {
+	const diagnostics = [];
+	const files = getSourceFiles(context);
+	for (const filePath of files) {
+		if (!GO_EXTENSIONS.has(path.extname(filePath))) continue;
+		if (isAutoGenerated(filePath)) continue;
+		if (filePath.endsWith("_test.go")) continue;
+		let content;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const lines = content.split("\n");
+		const pkg = detectPackageName(lines);
+		if (!pkg) continue;
+		flagLibraryPanic(lines, path.relative(context.rootDirectory, filePath), pkg, diagnostics);
+	}
+	return diagnostics;
+};
+
+//#endregion
+//#region src/engines/ai-slop/python-data.ts
+const PYTHON_STDLIB = new Set([
+	"__future__",
+	"_thread",
+	"abc",
+	"argparse",
+	"array",
+	"ast",
+	"asyncio",
+	"atexit",
+	"base64",
+	"binascii",
+	"bisect",
+	"builtins",
+	"bz2",
+	"calendar",
+	"codecs",
+	"collections",
+	"concurrent",
+	"configparser",
+	"contextlib",
+	"contextvars",
+	"copy",
+	"csv",
+	"ctypes",
+	"dataclasses",
+	"datetime",
+	"decimal",
+	"difflib",
+	"dis",
+	"doctest",
+	"email",
+	"encodings",
+	"enum",
+	"errno",
+	"faulthandler",
+	"filecmp",
+	"fileinput",
+	"fnmatch",
+	"fractions",
+	"functools",
+	"gc",
+	"getopt",
+	"getpass",
+	"gettext",
+	"glob",
+	"graphlib",
+	"gzip",
+	"hashlib",
+	"heapq",
+	"hmac",
+	"html",
+	"http",
+	"imaplib",
+	"importlib",
+	"inspect",
+	"io",
+	"ipaddress",
+	"itertools",
+	"json",
+	"keyword",
+	"linecache",
+	"locale",
+	"logging",
+	"lzma",
+	"mailbox",
+	"math",
+	"mimetypes",
+	"mmap",
+	"multiprocessing",
+	"numbers",
+	"operator",
+	"os",
+	"pathlib",
+	"pdb",
+	"pickle",
+	"platform",
+	"plistlib",
+	"pprint",
+	"profile",
+	"pstats",
+	"pty",
+	"queue",
+	"quopri",
+	"random",
+	"re",
+	"readline",
+	"reprlib",
+	"resource",
+	"secrets",
+	"select",
+	"selectors",
+	"shelve",
+	"shlex",
+	"shutil",
+	"signal",
+	"site",
+	"smtplib",
+	"socket",
+	"socketserver",
+	"sqlite3",
+	"ssl",
+	"stat",
+	"statistics",
+	"string",
+	"stringprep",
+	"struct",
+	"subprocess",
+	"sunau",
+	"symtable",
+	"sys",
+	"sysconfig",
+	"syslog",
+	"tarfile",
+	"telnetlib",
+	"tempfile",
+	"termios",
+	"test",
+	"textwrap",
+	"threading",
+	"time",
+	"timeit",
+	"tkinter",
+	"token",
+	"tokenize",
+	"tomllib",
+	"trace",
+	"traceback",
+	"tracemalloc",
+	"tty",
+	"turtle",
+	"types",
+	"typing",
+	"unicodedata",
+	"unittest",
+	"urllib",
+	"uu",
+	"uuid",
+	"venv",
+	"warnings",
+	"wave",
+	"weakref",
+	"webbrowser",
+	"winreg",
+	"winsound",
+	"wsgiref",
+	"xml",
+	"xmlrpc",
+	"zipapp",
+	"zipfile",
+	"zipimport",
+	"zlib",
+	"zoneinfo"
+]);
+const PYTHON_IMPORT_TO_PIP = {
+	yaml: "pyyaml",
+	PIL: "pillow",
+	dateutil: "python-dateutil",
+	cv2: "opencv-python",
+	sklearn: "scikit-learn",
+	bs4: "beautifulsoup4",
+	typing_extensions: "typing-extensions",
+	google: "google-api-python-client",
+	jose: "python-jose",
+	jwt: "pyjwt",
+	OpenSSL: "pyopenssl",
+	magic: "python-magic",
+	docx: "python-docx",
+	pptx: "python-pptx",
+	git: "gitpython",
+	socks: "pysocks",
+	redis: "redis"
+};
+
+//#endregion
+//#region src/engines/ai-slop/hallucinated-imports.ts
+const JS_EXTENSIONS$2 = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const PY_EXTENSIONS$2 = new Set([".py"]);
+const readJson = (filePath) => {
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		return null;
+	}
+};
+const PKG_DEP_SECTIONS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+const addDepsFromPkg = (pkg, jsDeps) => {
+	for (const section of PKG_DEP_SECTIONS) {
+		const deps = pkg[section];
+		if (deps && typeof deps === "object") for (const name of Object.keys(deps)) jsDeps.add(name);
+	}
+};
+const readWorkspaceGlobs = (rootDir, rootPkg) => {
+	const globs = [];
+	if (rootPkg && typeof rootPkg === "object") {
+		const ws = rootPkg.workspaces;
+		if (Array.isArray(ws)) {
+			for (const g of ws) if (typeof g === "string") globs.push(g);
+		} else if (ws && typeof ws === "object") {
+			const pkgs = ws.packages;
+			if (Array.isArray(pkgs)) {
+				for (const g of pkgs) if (typeof g === "string") globs.push(g);
+			}
+		}
+	}
+	const lerna = readJson(path.join(rootDir, "lerna.json"));
+	if (lerna && Array.isArray(lerna.packages)) {
+		for (const g of lerna.packages) if (typeof g === "string") globs.push(g);
+	}
+	try {
+		const pnpmWs = fs.readFileSync(path.join(rootDir, "pnpm-workspace.yaml"), "utf-8");
+		let inPackages = false;
+		for (const rawLine of pnpmWs.split("\n")) {
+			if (/^packages\s*:\s*$/.test(rawLine)) {
+				inPackages = true;
+				continue;
+			}
+			if (!inPackages) continue;
+			if (/^\S/.test(rawLine)) break;
+			const m = rawLine.match(/^\s*-\s*["']?([^"'\n]+?)["']?\s*$/);
+			if (m) globs.push(m[1].trim());
+		}
+	} catch {}
+	return globs;
+};
+const expandWorkspaceDirs = (rootDir, globs) => {
+	const dirs = [];
+	for (const glob of globs) if (glob.endsWith("/*")) {
+		const parent = path.join(rootDir, glob.slice(0, -2));
+		try {
+			for (const entry of fs.readdirSync(parent, { withFileTypes: true })) if (entry.isDirectory()) dirs.push(path.join(parent, entry.name));
+		} catch {
+			continue;
+		}
+	} else if (!glob.includes("*")) dirs.push(path.join(rootDir, glob));
+	return dirs;
+};
+const SKIP_DIRS = new Set([
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	"out",
+	"target",
+	"coverage"
+]);
+const NESTED_PKG_JSON_DEPTH = 4;
+const collectNestedManifests = (rootDir, jsDeps) => {
+	const walk = (dir, depth) => {
+		if (depth > NESTED_PKG_JSON_DEPTH) return;
+		let entries;
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+			if (SKIP_DIRS.has(entry.name)) continue;
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) walk(full, depth + 1);
+			else if (entry.name === "package.json" && depth > 0) {
+				const wsPkg = readJson(full);
+				if (!wsPkg) continue;
+				if (typeof wsPkg.name === "string") jsDeps.add(wsPkg.name);
+				addDepsFromPkg(wsPkg, jsDeps);
+			}
+		}
+	};
+	walk(rootDir, 0);
+};
+const collectJsDeps = (rootDir, jsDeps) => {
+	const pkgPath = path.join(rootDir, "package.json");
+	if (!fs.existsSync(pkgPath)) return false;
+	const pkg = readJson(pkgPath);
+	if (!pkg || typeof pkg !== "object") return false;
+	addDepsFromPkg(pkg, jsDeps);
+	if (typeof pkg.name === "string") jsDeps.add(pkg.name);
+	const workspaceDirs = expandWorkspaceDirs(rootDir, readWorkspaceGlobs(rootDir, pkg));
+	for (const wsDir of workspaceDirs) {
+		const wsPkg = readJson(path.join(wsDir, "package.json"));
+		if (!wsPkg) continue;
+		if (typeof wsPkg.name === "string") jsDeps.add(wsPkg.name);
+		addDepsFromPkg(wsPkg, jsDeps);
+	}
+	collectNestedManifests(rootDir, jsDeps);
+	return true;
+};
+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);
+	return {
+		jsDeps,
+		pyDeps,
+		hasJsManifest,
+		hasPyManifest: hasReq || hasPyproject || hasPipfile
+	};
+};
+const isJsRelativeOrAbsolute = (spec) => spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("~/");
+const isJsBuiltin = (spec) => {
+	return isBuiltin(spec.startsWith("node:") ? spec.slice(5) : spec) || isBuiltin(spec);
+};
+const VIRTUAL_MODULE_PREFIXES = [
+	"astro:",
+	"virtual:",
+	"bun:"
+];
+const isJsVirtualModule = (spec) => VIRTUAL_MODULE_PREFIXES.some((p) => spec.startsWith(p));
+const TEMPLATE_PLACEHOLDER_RE = /\$\{/;
+const isLikelyRealImportSpec = (spec) => {
+	if (spec.length === 0) return false;
+	if (TEMPLATE_PLACEHOLDER_RE.test(spec)) return false;
+	if (spec.includes("\\")) return false;
+	if (/\s/.test(spec)) return false;
+	return true;
+};
+const packageNameFromImport = (spec) => {
+	if (spec.startsWith("@")) {
+		const parts = spec.split("/");
+		return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : spec;
+	}
+	return spec.split("/")[0];
+};
+const STATIC_IMPORT_RE = /^\s*import\s+(?:[\w*{},\s]+\s+from\s+)?["']([^"']+)["']/;
+const DYNAMIC_IMPORT_RE = /(?:import|require)\s*\(\s*["']([^"']+)["']/g;
+const extractJsImports = (content) => {
+	const lines = content.split("\n");
+	const results = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const trimmed = line.trim();
+		if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+		const staticMatch = STATIC_IMPORT_RE.exec(line);
+		if (staticMatch && isLikelyRealImportSpec(staticMatch[1])) results.push({
+			spec: staticMatch[1],
+			line: i + 1
+		});
+		DYNAMIC_IMPORT_RE.lastIndex = 0;
+		let dyn = DYNAMIC_IMPORT_RE.exec(line);
+		while (dyn !== null) {
+			if (isLikelyRealImportSpec(dyn[1])) results.push({
+				spec: dyn[1],
+				line: i + 1
+			});
+			dyn = DYNAMIC_IMPORT_RE.exec(line);
+		}
+	}
+	return results;
+};
+const extractPyImports = (content) => {
+	const lines = content.split("\n");
+	const results = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (line.startsWith("#")) continue;
+		const fromMatch = line.match(/^from\s+([\w.]+)\s+import\b/);
+		if (fromMatch && !fromMatch[1].startsWith(".")) {
+			results.push({
+				spec: fromMatch[1],
+				line: i + 1
+			});
+			continue;
+		}
+		const importMatch = line.match(/^import\s+([\w.,\s]+?)(?:\s+as\s+\w+)?\s*$/);
+		if (importMatch) for (const raw of importMatch[1].split(",")) {
+			const cleaned = raw.trim().split(/\s+as\s+/)[0];
+			if (cleaned && !cleaned.startsWith(".")) results.push({
+				spec: cleaned,
+				line: i + 1
+			});
+		}
+	}
+	return results;
+};
+const checkJsImport = (spec, manifest) => {
+	if (isJsRelativeOrAbsolute(spec)) return null;
+	if (isJsBuiltin(spec)) return null;
+	if (isJsVirtualModule(spec)) return null;
+	const pkg = packageNameFromImport(spec);
+	if (manifest.jsDeps.has(pkg)) return null;
+	if (pkg.startsWith("@types/")) {
+		const realPkg = pkg.slice(7);
+		if (manifest.jsDeps.has(realPkg)) return null;
+	}
+	return pkg;
+};
+const checkPyImport = (spec, manifest) => {
+	const root = spec.split(".")[0];
+	if (PYTHON_STDLIB.has(root)) return null;
+	const normalized = root.toLowerCase().replace(/_/g, "-");
+	if (manifest.pyDeps.has(normalized)) return null;
+	const pipName = PYTHON_IMPORT_TO_PIP[root];
+	if (pipName && manifest.pyDeps.has(pipName)) return null;
+	return root;
+};
+const detectHallucinatedImports = async (context) => {
+	const manifest = loadManifest(context.rootDirectory);
+	if (!manifest.hasJsManifest && !manifest.hasPyManifest) return [];
+	const diagnostics = [];
+	const files = getSourceFiles(context);
+	for (const filePath of files) {
+		const ext = path.extname(filePath);
+		const isJs = JS_EXTENSIONS$2.has(ext);
+		const isPy = PY_EXTENSIONS$2.has(ext);
+		if (!isJs && !isPy) continue;
+		if (isJs && !manifest.hasJsManifest) continue;
+		if (isPy && !manifest.hasPyManifest) continue;
+		if (isAutoGenerated(filePath)) continue;
+		let content;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const relPath = path.relative(context.rootDirectory, filePath);
+		const imports = isJs ? extractJsImports(content) : extractPyImports(content);
+		for (const { spec, line } of imports) {
+			const hallucinated = isJs ? checkJsImport(spec, manifest) : checkPyImport(spec, manifest);
+			if (!hallucinated) continue;
+			const manifestLabel = isJs ? "package.json" : "requirements.txt / pyproject.toml / Pipfile";
+			diagnostics.push({
+				filePath: relPath,
+				engine: "ai-slop",
+				rule: "ai-slop/hallucinated-import",
+				severity: "error",
+				message: `Imports "${hallucinated}" but it's not declared in ${manifestLabel}${isPy ? " and isn't Python stdlib" : ""}`,
+				help: "Most often this is an LLM hallucinating a plausible-sounding package name. Either add the package to your manifest, or correct the import.",
+				line,
+				column: 1,
+				category: "AI Slop",
+				fixable: false
+			});
+		}
+	}
+	return diagnostics;
+};
+
 //#endregion
 //#region src/engines/ai-slop/narrative-comments-patterns.ts
 const DECORATIVE_SEPARATOR = /^[-=─━~_*#]{6,}$/;
@@ -1020,6 +1784,7 @@ const PHP_DECL_START = /^\s*(?:public|private|protected|static|final|abstract|re
 
 //#endregion
 //#region src/engines/ai-slop/narrative-comments.ts
+const NON_PRODUCTION_DIR_PATTERN = /(?:^|\/)(?:scripts|bin|examples?|demos?|bench|benches|benchmarks?|fixtures?|__fixtures__|__mocks__|__tests__|vendor|_vendor|vendored|third_party|blib2to3|lib2to3)\//i;
 const stripJsdocLine = (line) => line.replace(/^\s*\/\*\*+\s?/, "").replace(/\s*\*+\/\s*$/, "").replace(/^\s*\*\s?/, "").trim();
 const stripLineComment = (line) => line.replace(/^\s*(?:(?:\/\/)|#)\s?/, "");
 const getCommentSyntax = (ext) => {
@@ -1048,6 +1813,10 @@ const getMatchedLinePrefix = (line, syntax) => {
 	}
 	return null;
 };
+const isRustDocCommentLine = (line) => {
+	const trimmed = line.trimStart();
+	return trimmed.startsWith("///") || trimmed.startsWith("//!");
+};
 const collectBlocks = (sourceLines, syntax) => {
 	const blocks = [];
 	let i = 0;
@@ -1063,6 +1832,8 @@ const collectBlocks = (sourceLines, syntax) => {
 			}
 			let next = i;
 			while (next < sourceLines.length && sourceLines[next].trim() === "") next += 1;
+			const docCandidates = raw.filter((l) => l.trim().length > 0);
+			const isRustDoc = docCandidates.length > 0 && docCandidates.every((l) => isRustDocCommentLine(l));
 			blocks.push({
 				kind: "line",
 				startLine: start + 1,
@@ -1070,6 +1841,7 @@ const collectBlocks = (sourceLines, syntax) => {
 				rawLines: raw,
 				prose: raw.map(stripLineComment),
 				hasMeaningfulJsdocTag: false,
+				isRustDoc,
 				nextNonBlankLine: next < sourceLines.length ? sourceLines[next] : null
 			});
 			continue;
@@ -1103,6 +1875,7 @@ const collectBlocks = (sourceLines, syntax) => {
 				rawLines: raw,
 				prose,
 				hasMeaningfulJsdocTag: hasMeaningful,
+				isRustDoc: false,
 				nextNonBlankLine: next < sourceLines.length ? sourceLines[next] : null
 			});
 			continue;
@@ -1153,6 +1926,22 @@ const nextLineLooksLikeDataEntry = (nextLine) => {
 	return false;
 };
 const looksLikeSuppressDirective = (block) => block.rawLines.some((l) => /\b(biome-ignore|eslint-disable|ts-ignore|ts-expect-error|@ts-\w+|noqa|pylint:\s*disable|rubocop:disable|noinspection|phpcs:disable)\b/.test(l));
+const GO_DECL_NAME_RE = /^(?:func|type|var|const)\s+(?:\([^)]*\)\s*)?(\w+)/;
+const looksLikeGoDocComment = (block, ext) => {
+	if (ext !== ".go" || block.kind !== "line") return false;
+	const next = block.nextNonBlankLine;
+	if (!next) return false;
+	const declMatch = GO_DECL_NAME_RE.exec(next.trim());
+	if (!declMatch) return false;
+	return ((block.prose.find((l) => l.length > 0) ?? "").split(/\s+/)[0] ?? "") === declMatch[1];
+};
+const DOC_INDICATOR_RE = /`[^`]+`|\|\s*[-:]+\s*\||```|\b(?:note|warning|warn|caveat|example|caution|see):/i;
+const hasDocIndicator = (block) => {
+	const joined = block.prose.join(" ");
+	if (DOC_INDICATOR_RE.test(joined)) return true;
+	for (const l of block.prose) if (/^[-]\s/.test(l)) return true;
+	return false;
+};
 const detectNarrativeInBlock = (block, ext) => {
 	if (looksLikeLicenseHeader(block)) return {
 		matched: false,
@@ -1166,6 +1955,14 @@ const detectNarrativeInBlock = (block, ext) => {
 		matched: false,
 		reason: ""
 	};
+	if (block.isRustDoc) return {
+		matched: false,
+		reason: ""
+	};
+	if (looksLikeGoDocComment(block, ext)) return {
+		matched: false,
+		reason: ""
+	};
 	if (block.kind === "line" && block.prose.some((l) => DECORATIVE_SEPARATOR.test(l) || DECORATIVE_SECTION_HEADER.test(l))) return {
 		matched: true,
 		reason: "decorative separator"
@@ -1178,11 +1975,16 @@ const detectNarrativeInBlock = (block, ext) => {
 		matched: true,
 		reason: "bare section label"
 	};
+	const joined = block.prose.join(" ");
+	const hasWhyMarker = EXPLANATORY_WHY_MARKERS.test(joined);
+	if ((hasWhyMarker || hasDocIndicator(block)) && block.kind === "jsdoc") return {
+		matched: false,
+		reason: ""
+	};
 	if (block.prose.length >= 3 && looksLikeDeclarationPreamble(block.nextNonBlankLine, ext)) return {
 		matched: true,
 		reason: block.kind === "jsdoc" ? "JSDoc preamble before declaration" : "multi-line preamble before declaration"
 	};
-	const joined = block.prose.join(" ");
 	if (CROSS_REFERENCE_PHRASES.some((re) => re.test(joined))) return {
 		matched: true,
 		reason: "cross-reference commentary"
@@ -1198,8 +2000,6 @@ const detectNarrativeInBlock = (block, ext) => {
 		reason: "explanatory preamble"
 	};
 	const nonEmptyProseCount = block.prose.filter((l) => l.length > 0).length;
-	const joinedProse = block.prose.join(" ");
-	const hasWhyMarker = EXPLANATORY_WHY_MARKERS.test(joinedProse);
 	if (nonEmptyProseCount >= 5) return {
 		matched: true,
 		reason: "long narrative block"
@@ -1213,84 +2013,330 @@ const detectNarrativeInBlock = (block, ext) => {
 		reason: ""
 	};
 };
-const detectNarrativeComments = async (context) => {
-	const files = getSourceFiles(context);
+const detectNarrativeComments = async (context) => {
+	const files = getSourceFiles(context);
+	const diagnostics = [];
+	for (const filePath of files) {
+		const ext = path.extname(filePath);
+		if (!SUPPORTED_EXTS.has(ext)) continue;
+		if (isAutoGenerated(filePath)) continue;
+		const syntax = getCommentSyntax(ext);
+		if (!syntax) continue;
+		const relativePath = path.relative(context.rootDirectory, filePath);
+		if (NON_PRODUCTION_DIR_PATTERN.test(relativePath)) continue;
+		let content;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const blocks = collectBlocks(content.split("\n"), syntax);
+		for (const block of blocks) {
+			const { matched, reason } = detectNarrativeInBlock(block, ext);
+			if (!matched) continue;
+			diagnostics.push({
+				filePath: relativePath,
+				engine: "ai-slop",
+				rule: "ai-slop/narrative-comment",
+				severity: "warning",
+				message: `Narrative comment block (${reason})`,
+				help: "Remove — narrative/decorative comments belong in PR descriptions, not source. Code should be self-explanatory.",
+				line: block.startLine,
+				column: 0,
+				category: "Comments",
+				fixable: true
+			});
+		}
+	}
+	return diagnostics;
+};
+
+//#endregion
+//#region src/engines/ai-slop/python-patterns.ts
+const PY_EXTENSIONS$1 = new Set([".py"]);
+const BARE_EXCEPT_RE = /^\s*except\s*:\s*(?:#.*)?$/;
+const BROAD_EXCEPT_RE = /^\s*except\s+(Exception|BaseException)\s*(?:as\s+\w+)?\s*:\s*(?:#.*)?$/;
+const PRINT_RE = /^\s*print\s*\(/;
+const DEF_RE = /^\s*(?:async\s+)?def\s+\w+\s*\(/;
+const MUTABLE_DEFAULT_RE = /(\w+)\s*(?::\s*[^,)=]+)?\s*=\s*(\[\s*\]|\{\s*\}|set\(\s*\))/;
+const isTestFile$1 = (relPath, basename) => basename.startsWith("test_") || basename.endsWith("_test.py") || basename === "conftest.py" || relPath.split(path.sep).some((seg) => seg === "tests" || seg === "test");
+const isScriptOrEntrypoint = (basename) => basename === "__main__.py" || basename === "manage.py" || basename === "setup.py";
+const SCRIPT_DIR_NAMES = new Set([
+	"scripts",
+	"bin",
+	".github",
+	"action",
+	"docs",
+	"docs_src",
+	"examples",
+	"example"
+]);
+const isInScriptDir = (relPath) => relPath.split(path.sep).some((seg) => SCRIPT_DIR_NAMES.has(seg));
+const isTutorialFile = (basename) => basename.startsWith("tutorial") && basename.endsWith(".py");
+const MAIN_GUARD_RE = /^\s*if\s+__name__\s*==\s*["']__main__["']\s*:/;
+const hasMainGuard = (lines) => lines.some((l) => MAIN_GUARD_RE.test(l));
+const buildDocstringRanges = (lines) => {
+	const inside = /* @__PURE__ */ new Set();
+	let openDelim = null;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (openDelim) {
+			inside.add(i);
+			if (line.includes(openDelim)) openDelim = null;
+			continue;
+		}
+		for (const delim of ["\"\"\"", "'''"]) {
+			const first = line.indexOf(delim);
+			if (first === -1) continue;
+			if (line.indexOf(delim, first + 3) === -1) {
+				openDelim = delim;
+				inside.add(i);
+				break;
+			}
+		}
+	}
+	return inside;
+};
+const pushFinding = (out, a) => {
+	out.push({
+		filePath: a.relPath,
+		engine: "ai-slop",
+		rule: a.rule,
+		severity: a.severity,
+		message: a.message,
+		help: a.help,
+		line: a.line,
+		column: 1,
+		category: "AI Slop",
+		fixable: false
+	});
+};
+const flagBareExcept = (lines, relPath, out) => {
+	for (let i = 0; i < lines.length; i++) {
+		if (!BARE_EXCEPT_RE.test(lines[i])) continue;
+		pushFinding(out, {
+			relPath,
+			rule: "ai-slop/python-bare-except",
+			severity: "warning",
+			message: "Bare `except:` swallows every exception including KeyboardInterrupt and SystemExit.",
+			help: "Catch the specific exception type you actually expect (`except ValueError:`, `except (KeyError, IndexError):`). If you genuinely want everything, `except BaseException:` plus a re-raise or log makes the intent explicit.",
+			line: i + 1
+		});
+	}
+};
+const flagBroadExceptWithSilentBody = (lines, relPath, out) => {
+	for (let i = 0; i < lines.length; i++) {
+		const match = BROAD_EXCEPT_RE.exec(lines[i]);
+		if (!match) continue;
+		const trimmedNext = (lines[i + 1] ?? "").trim();
+		if (!(trimmedNext === "pass" || trimmedNext.startsWith("#") && (lines[i + 2] ?? "").trim() === "pass")) continue;
+		pushFinding(out, {
+			relPath,
+			rule: "ai-slop/python-broad-except",
+			severity: "warning",
+			message: `\`except ${match[1]}: pass\` silently drops every exception. Failures vanish without a trace.`,
+			help: "Either narrow the exception class (`except ValueError:`), log the error, or re-raise. If you genuinely intend to swallow, add a comment naming the specific failure mode you're handling — auditors will thank you.",
+			line: i + 1
+		});
+	}
+};
+const flagMutableDefaults = (lines, relPath, out) => {
+	let i = 0;
+	while (i < lines.length) {
+		if (!DEF_RE.test(lines[i])) {
+			i++;
+			continue;
+		}
+		const startLine = i;
+		let signature = lines[i];
+		let parenDepth = 0;
+		for (const ch of signature) if (ch === "(") parenDepth++;
+		else if (ch === ")") parenDepth--;
+		while (parenDepth > 0 && i + 1 < lines.length) {
+			i++;
+			signature += `\n${lines[i]}`;
+			for (const ch of lines[i]) if (ch === "(") parenDepth++;
+			else if (ch === ")") parenDepth--;
+		}
+		MUTABLE_DEFAULT_RE.lastIndex = 0;
+		const found = MUTABLE_DEFAULT_RE.exec(signature);
+		if (found) pushFinding(out, {
+			relPath,
+			rule: "ai-slop/python-mutable-default",
+			severity: "warning",
+			message: `Mutable default argument \`${found[1]}=${found[2]}\`. The default is shared across all calls — bugs that look like state-leakage.`,
+			help: "Use `None` as the default and create the mutable value inside the body: `def f(items=None): items = items if items is not None else []`. Standard Python idiom; anything else is the AI agent shortcutting.",
+			line: startLine + 1
+		});
+		i++;
+	}
+};
+const flagPrintInProduction = (lines, relPath, basename, out) => {
+	if (isTestFile$1(relPath, basename) || isScriptOrEntrypoint(basename)) return;
+	if (isInScriptDir(relPath)) return;
+	if (isTutorialFile(basename)) return;
+	if (hasMainGuard(lines)) return;
+	const docstringLines = buildDocstringRanges(lines);
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!PRINT_RE.test(line)) continue;
+		if (line.trim().startsWith("#")) continue;
+		if (docstringLines.has(i)) continue;
+		pushFinding(out, {
+			relPath,
+			rule: "ai-slop/python-print-debug",
+			severity: "warning",
+			message: "`print()` in production code — usually a leftover debug statement.",
+			help: "Use the project's logger (`logging.getLogger(__name__).info(...)`). If this file is genuinely a CLI entry point (typer/click/argparse), it's safe to ignore — but rename to `__main__.py` or move under `scripts/` so the rule skips it next time.",
+			line: i + 1
+		});
+	}
+};
+const detectPythonPatterns = async (context) => {
 	const diagnostics = [];
+	const files = getSourceFiles(context);
 	for (const filePath of files) {
-		const ext = path.extname(filePath);
-		if (!SUPPORTED_EXTS.has(ext)) continue;
+		if (!PY_EXTENSIONS$1.has(path.extname(filePath))) continue;
 		if (isAutoGenerated(filePath)) continue;
-		const syntax = getCommentSyntax(ext);
-		if (!syntax) continue;
 		let content;
 		try {
 			content = fs.readFileSync(filePath, "utf-8");
 		} catch {
 			continue;
 		}
-		const blocks = collectBlocks(content.split("\n"), syntax);
-		const relativePath = filePath.replace(`${context.rootDirectory}/`, "");
-		for (const block of blocks) {
-			const { matched, reason } = detectNarrativeInBlock(block, ext);
-			if (!matched) continue;
-			diagnostics.push({
-				filePath: relativePath,
-				engine: "ai-slop",
-				rule: "ai-slop/narrative-comment",
-				severity: "warning",
-				message: `Narrative comment block (${reason})`,
-				help: "Remove — narrative/decorative comments belong in PR descriptions, not source. Code should be self-explanatory.",
-				line: block.startLine,
-				column: 0,
-				category: "Comments",
-				fixable: true
-			});
-		}
+		const relPath = path.relative(context.rootDirectory, filePath);
+		const basename = path.basename(filePath);
+		const lines = content.split("\n");
+		flagBareExcept(lines, relPath, diagnostics);
+		flagBroadExceptWithSilentBody(lines, relPath, diagnostics);
+		flagMutableDefaults(lines, relPath, diagnostics);
+		flagPrintInProduction(lines, relPath, basename, diagnostics);
 	}
 	return diagnostics;
 };
-const fixNarrativeComments = async (context) => {
-	const diagnostics = await detectNarrativeComments(context);
-	if (diagnostics.length === 0) return;
-	const byFile = /* @__PURE__ */ new Map();
-	for (const d of diagnostics) {
-		const abs = d.filePath.startsWith("/") ? d.filePath : `${context.rootDirectory}/${d.filePath}`;
-		const list = byFile.get(abs) ?? [];
-		list.push(d);
-		byFile.set(abs, list);
+
+//#endregion
+//#region src/engines/ai-slop/rust-patterns.ts
+const RUST_EXTENSIONS = new Set([".rs"]);
+const UNWRAP_CALL_RE = /\.unwrap\s*\(\s*\)/;
+const TODO_MACRO_RE = /\b(todo|unimplemented)\s*!\s*\(/;
+const COMMENT_LINE_RE = /^\s*\/\//;
+const TEST_ATTR_RE = /^\s*#\s*\[\s*(?:cfg\s*\(\s*test\s*\)|test|tokio::test)/;
+const WRITELN_UNWRAP_RE = /\b(?:writeln|write)\s*!\s*\([^)]*\)\s*\.unwrap\s*\(\s*\)/;
+const TEST_BASENAMES = new Set([
+	"tests.rs",
+	"testutil.rs",
+	"test_util.rs",
+	"test_utils.rs",
+	"build.rs"
+]);
+const TEST_CRATE_SEGMENT_RE = /(?:^|[-_])tests?(?:$|[-_])/;
+const isTestFile = (relPath) => {
+	const segments = relPath.split(path.sep);
+	if (segments.some((s) => TEST_CRATE_SEGMENT_RE.test(s))) return true;
+	const basename = segments[segments.length - 1] ?? "";
+	if (TEST_BASENAMES.has(basename)) return true;
+	return basename.endsWith("_tests.rs") || basename.endsWith("_testutil.rs");
+};
+const isExampleFile = (relPath) => relPath.split(path.sep).some((seg) => seg === "examples" || seg === "benches");
+const UNWRAP_INTENT_LOOKBACK = 2;
+const hasIntentComment = (lines, lineIdx) => {
+	for (let j = lineIdx - 1; j >= Math.max(0, lineIdx - UNWRAP_INTENT_LOOKBACK); j--) if (COMMENT_LINE_RE.test(lines[j])) return true;
+	return false;
+};
+const buildTestRanges = (lines) => {
+	const ranges = [];
+	for (let i = 0; i < lines.length; i++) {
+		if (!TEST_ATTR_RE.test(lines[i])) continue;
+		const openLine = i;
+		let depth = 0;
+		let started = false;
+		for (let j = i; j < lines.length; j++) {
+			const line = lines[j];
+			for (const ch of line) if (ch === "{") {
+				depth++;
+				started = true;
+			} else if (ch === "}") depth--;
+			if (started && depth === 0) {
+				ranges.push([openLine, j]);
+				i = j;
+				break;
+			}
+		}
 	}
-	for (const [filePath, diags] of byFile) {
-		const syntax = getCommentSyntax(path.extname(filePath));
-		if (!syntax) continue;
+	return ranges;
+};
+const isInRange = (ranges, lineIdx) => ranges.some(([start, end]) => lineIdx >= start && lineIdx <= end);
+const flagNonTestUnwrap = (lines, relPath, testRanges, out) => {
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (COMMENT_LINE_RE.test(line)) continue;
+		if (isInRange(testRanges, i)) continue;
+		if (!UNWRAP_CALL_RE.test(line)) continue;
+		if (WRITELN_UNWRAP_RE.test(line)) continue;
+		if (hasIntentComment(lines, i)) continue;
+		out.push({
+			filePath: relPath,
+			engine: "ai-slop",
+			rule: "ai-slop/rust-non-test-unwrap",
+			severity: "warning",
+			message: "`.unwrap()` in non-test code panics on None/Err. Surfaces as a hard crash for the caller.",
+			help: "Use `?` to propagate, `.expect(\"context\")` if you really mean it (and the message names the invariant), or pattern-match the variant you care about. Reserve raw `.unwrap()` for tests and prototypes.",
+			line: i + 1,
+			column: 1,
+			category: "AI Slop",
+			fixable: false
+		});
+	}
+};
+const flagTodoMacro = (lines, relPath, out) => {
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (COMMENT_LINE_RE.test(line)) continue;
+		const match = TODO_MACRO_RE.exec(line);
+		if (!match) continue;
+		out.push({
+			filePath: relPath,
+			engine: "ai-slop",
+			rule: "ai-slop/rust-todo-stub",
+			severity: "warning",
+			message: `\`${match[1]}!()\` panics at runtime — almost certainly a stub the agent forgot to fill in.`,
+			help: "Implement the missing path or remove it. If the work is genuinely deferred, file a ticket and put the number in a comment next to the macro so it doesn't ship invisibly.",
+			line: i + 1,
+			column: 1,
+			category: "AI Slop",
+			fixable: false
+		});
+	}
+};
+const detectRustPatterns = async (context) => {
+	const diagnostics = [];
+	const files = getSourceFiles(context);
+	for (const filePath of files) {
+		if (!RUST_EXTENSIONS.has(path.extname(filePath))) continue;
+		if (isAutoGenerated(filePath)) continue;
 		let content;
 		try {
 			content = fs.readFileSync(filePath, "utf-8");
 		} catch {
 			continue;
 		}
+		const relPath = path.relative(context.rootDirectory, filePath);
 		const lines = content.split("\n");
-		const blocks = collectBlocks(lines, syntax);
-		const toRemove = /* @__PURE__ */ new Set();
-		for (const d of diags) {
-			const block = blocks.find((b) => b.startLine === d.line);
-			if (!block) continue;
-			for (let ln = block.startLine; ln <= block.endLine; ln += 1) toRemove.add(ln);
-			const prev = block.startLine - 1;
-			const next = block.endLine + 1;
-			const prevIsBlank = prev >= 1 && lines[prev - 1]?.trim() === "";
-			const nextIsBlank = next <= lines.length && lines[next - 1]?.trim() === "";
-			if (prevIsBlank && nextIsBlank) toRemove.add(prev);
+		if (isExampleFile(relPath)) continue;
+		if (isTestFile(relPath)) {
+			flagTodoMacro(lines, relPath, diagnostics);
+			continue;
 		}
-		const kept = [];
-		for (let i = 0; i < lines.length; i += 1) if (!toRemove.has(i + 1)) kept.push(lines[i]);
-		const newContent = kept.join("\n");
-		if (newContent !== content) fs.writeFileSync(filePath, newContent);
+		flagNonTestUnwrap(lines, relPath, buildTestRanges(lines), diagnostics);
+		flagTodoMacro(lines, relPath, diagnostics);
 	}
+	return diagnostics;
 };
 
 //#endregion
 //#region src/engines/ai-slop/unused-imports.ts
-const JS_EXTENSIONS = new Set([
+const JS_EXTENSIONS$1 = new Set([
 	".ts",
 	".tsx",
 	".js",
@@ -1420,7 +2466,7 @@ const analyzeFile = (filePath) => {
 	const lines = content.split("\n");
 	let symbols;
 	let importLines;
-	if (JS_EXTENSIONS.has(ext)) {
+	if (JS_EXTENSIONS$1.has(ext)) {
 		const result = extractJsImportedSymbols(lines);
 		symbols = result.symbols;
 		importLines = result.importLines;
@@ -1476,7 +2522,12 @@ const aiSlopEngine = {
 			detectOverAbstraction(context),
 			detectDeadPatterns(context),
 			detectUnusedImports(context),
-			detectNarrativeComments(context)
+			detectNarrativeComments(context),
+			detectDuplicateImports(context),
+			detectPythonPatterns(context),
+			detectGoPatterns(context),
+			detectRustPatterns(context),
+			detectHallucinatedImports(context)
 		]);
 		for (const result of results) if (result.status === "fulfilled") diagnostics.push(...result.value);
 		return {
@@ -1872,6 +2923,12 @@ const isDataFile = (content) => {
 	const dataLinePattern = /^\s*[{}[\]"']/;
 	return nonEmpty.filter((l) => dataLinePattern.test(l)).length / nonEmpty.length > .8;
 };
+const TEST_PATH_RE = /(?:^|\/)(?:tests?|spec|specs|__tests__|__spec__|src\/test)\//i;
+const TEST_BASENAME_RE = /(?:^|[/.])(?:test_[\w-]+\.(?:py|rb)|[\w-]+_(?:test|spec)\.(?:py|rb|go|rs)|[\w-]+\.(?:test|spec)\.(?:[jt]sx?|mjs|cjs)|conftest\.py|[A-Z]\w*Tests?\.(?:java|cs|php))$/;
+const MIGRATION_PATH_RE = /(?:^|\/)(?:migrations?|migrate|prisma\/migrations|db\/migrate)\//i;
+const FIXTURE_PATH_RE = /(?:^|\/)(?:__fixtures__|__snapshots__|__mocks__|fixtures?|snapshots?|seeds?|stubs?)\//i;
+const GENERATED_PATH_RE = /(?:^|\/)(?:generated|gen|build|dist|out|target|coverage|node_modules|vendor|\.next|\.nuxt|\.svelte-kit)\//i;
+const isExemptFromComplexity = (relativePath) => TEST_PATH_RE.test(relativePath) || TEST_BASENAME_RE.test(relativePath) || MIGRATION_PATH_RE.test(relativePath) || FIXTURE_PATH_RE.test(relativePath) || GENERATED_PATH_RE.test(relativePath);
 const analyzeFunctions = (content, ext) => {
 	const lines = content.split("\n");
 	const functions = [];
@@ -1900,13 +2957,13 @@ const checkFileDiagnostics = (relativePath, content, limits) => {
 	const lineCount = content.split("\n").length;
 	const ext = path.extname(relativePath).toLowerCase();
 	if (isDataFile(content)) return results;
-	const effectiveMax = ext === ".jsx" || ext === ".tsx" ? Math.ceil(limits.maxFileLoc * JSX_FILE_LOC_MULTIPLIER) : limits.maxFileLoc;
-	if (lineCount > effectiveMax) results.push({
+	const configuredMax = ext === ".jsx" || ext === ".tsx" ? Math.ceil(limits.maxFileLoc * JSX_FILE_LOC_MULTIPLIER) : limits.maxFileLoc;
+	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: ${effectiveMax})`,
+		message: `File has ${lineCount} lines (max: ${configuredMax})`,
 		help: "Consider splitting this file into smaller modules",
 		line: 0,
 		column: 0,
@@ -1956,13 +3013,14 @@ const checkFunctionDiagnostics = (relativePath, fn, limits) => {
 	return results;
 };
 const checkFileComplexity = (filePath, rootDirectory, limits) => {
+	const relativePath = path.relative(rootDirectory, filePath);
+	if (isExemptFromComplexity(relativePath)) return [];
 	let content;
 	try {
 		content = fs.readFileSync(filePath, "utf-8");
 	} catch {
 		return [];
 	}
-	const relativePath = path.relative(rootDirectory, filePath);
 	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));
@@ -3538,7 +4596,10 @@ const lintEngine = {
 		const diagnostics = [];
 		const { languages, installedTools } = context;
 		const promises = [];
-		if (languages.includes("typescript") || languages.includes("javascript")) promises.push(runOxlint(context));
+		if (languages.includes("typescript") || languages.includes("javascript")) {
+			promises.push(runOxlint(context));
+			if (context.config.lint.typecheck) promises.push(import("./typecheck-B1MXNAy-.js").then((mod) => mod.runTypecheck(context)));
+		}
 		if (context.frameworks.includes("expo")) promises.push(Promise.resolve().then(() => expo_doctor_exports).then((mod) => mod.runExpoDoctor(context)));
 		if (languages.includes("python") && installedTools["ruff"]) promises.push(runRuffLint(context));
 		if (languages.includes("go") && installedTools["golangci-lint"]) promises.push(runGolangciLint(context));
@@ -4556,6 +5617,7 @@ const runScopedScan = async (cwd, filePaths) => {
 				audit: false,
 				auditTimeout: 0
 			},
+			lint: { typecheck: false },
 			architectureRulesPath: config.engines.architecture ? rulesPath : void 0
 		}
 	}, {
@@ -4594,6 +5656,9 @@ const readIfExists = (targetPath) => {
 
 //#endregion
 //#region src/hooks/quality-gate/baseline.ts
+const fingerprintDiagnostic = (d, rootDirectory) => {
+	return `${path.isAbsolute(d.filePath) ? path.relative(rootDirectory, d.filePath) : d.filePath}:${d.line}:${d.rule}`;
+};
 const BASELINE_REL = path.join(".aislop", "baseline.json");
 const baselinePath = (cwd) => path.join(cwd, BASELINE_REL);
 const readBaseline = (cwd) => {
@@ -4601,8 +5666,16 @@ const readBaseline = (cwd) => {
 	if (!raw) return null;
 	try {
 		const parsed = JSON.parse(raw);
-		if (parsed.schema !== "aislop.baseline.v1") return null;
-		return parsed;
+		if (parsed.schema !== "aislop.baseline.v2" && parsed.schema !== "aislop.baseline.v1") return null;
+		return {
+			schema: "aislop.baseline.v2",
+			updatedAt: parsed.updatedAt ?? "",
+			score: parsed.score ?? 0,
+			byEngine: parsed.byEngine ?? {},
+			fileCount: parsed.fileCount ?? 0,
+			commit: parsed.commit,
+			findingFingerprints: parsed.findingFingerprints ?? []
+		};
 	} catch {
 		return null;
 	}
@@ -4626,7 +5699,8 @@ const captureBaseline = async (cwd) => {
 			security: {
 				audit: false,
 				auditTimeout: 0
-			}
+			},
+			lint: { typecheck: false }
 		}
 	}, {
 		format: config.engines.format,
@@ -4643,12 +5717,14 @@ const captureBaseline = async (cwd) => {
 		const { score: engineScore } = calculateScore(diagnostics.filter((d) => r.diagnostics.includes(d)), config.scoring.weights, config.scoring.thresholds, project.sourceFileCount, config.scoring.smoothing);
 		byEngine[r.engine] = engineScore;
 	}
+	const findingFingerprints = diagnostics.filter((d) => d.severity === "error" || d.severity === "warning").map((d) => fingerprintDiagnostic(d, project.rootDirectory));
 	const target = writeBaseline(cwd, {
-		schema: "aislop.baseline.v1",
+		schema: "aislop.baseline.v2",
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		score,
 		byEngine,
-		fileCount: project.sourceFileCount
+		fileCount: project.sourceFileCount,
+		findingFingerprints
 	});
 	return {
 		score,
@@ -4737,7 +5813,10 @@ const runClaudeHook = async (deps = {}) => {
 		const { diagnostics, score, rootDirectory } = await runScopedScan(cwd, files);
 		const baseline = readBaseline(cwd);
 		appendSessionFiles(cwd, files);
-		const feedback = buildFeedback(diagnostics, score, rootDirectory, baseline?.score);
+		const feedback = buildFeedback(diagnostics, score, rootDirectory, baseline ? {
+			score: baseline.score,
+			findingFingerprints: baseline.findingFingerprints
+		} : void 0);
 		const envelope = renderClaudeOutput(JSON.stringify(feedback));
 		write(JSON.stringify(envelope));
 		return 0;
@@ -4747,6 +5826,42 @@ const runClaudeHook = async (deps = {}) => {
 		release();
 	}
 };
+const parseClaudeFileChangedStdin = (raw) => {
+	if (!raw.trim()) return {};
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return {};
+	}
+};
+const runClaudeFileChangedHook = async (deps = {}) => {
+	const getStdin = deps.stdin ?? readStdin$2;
+	const write = deps.write ?? ((s) => process.stdout.write(s));
+	const input = parseClaudeFileChangedStdin(await getStdin());
+	const cwd = input.cwd && path.isAbsolute(input.cwd) ? input.cwd : process.cwd();
+	const release = acquireHookLock(cwd);
+	if (!release) return 0;
+	try {
+		const result = await captureBaseline(cwd);
+		const changed = input.file_path ? path.relative(cwd, input.file_path) || input.file_path : "<unknown>";
+		const envelope = renderClaudeOutput(JSON.stringify({
+			schema: "aislop.hook.v2",
+			event: "file_changed",
+			file: changed,
+			message: `Watched file changed (${changed}). aislop refreshed the baseline — score: ${result.score}.`,
+			baseline: {
+				score: result.score,
+				fileCount: result.fileCount
+			}
+		}));
+		write(JSON.stringify(envelope));
+		return 0;
+	} catch {
+		return 0;
+	} finally {
+		release();
+	}
+};
 const parseClaudeStopStdin = (raw) => {
 	if (!raw.trim()) return {};
 	try {
@@ -4769,7 +5884,10 @@ const runClaudeStopHook = async (deps = {}) => {
 	if (!release) return 0;
 	try {
 		const { diagnostics, score, rootDirectory } = await runScopedScan(cwd, sessionFiles);
-		const feedback = buildFeedback(diagnostics, score, rootDirectory, baseline.score);
+		const feedback = buildFeedback(diagnostics, score, rootDirectory, {
+			score: baseline.score,
+			findingFingerprints: baseline.findingFingerprints
+		});
 		if (!feedback.regressed) {
 			clearSessionFiles(cwd);
 			return 0;
@@ -4897,7 +6015,7 @@ const AISLOP_MD_BODY = `# aislop — agent instructions
 
 ## On every edit
 
-A PostToolUse hook runs \`aislop hook claude\` after every Edit, Write, or MultiEdit. It scans the touched files and returns findings as JSON \`additionalContext\` shaped like \`AislopFeedback\` (schema \`aislop.hook.v1\`). Act on them the same turn.
+A PostToolUse hook runs \`aislop hook claude\` after every Edit, Write, or MultiEdit. It scans the touched files and returns findings as JSON \`additionalContext\` shaped like \`AislopFeedback\` (schema \`aislop.hook.v2\` — score, baseline, delta, regressed, counts, findings, newSinceBaseline, suggestedActions). Act on them the same turn; the \`suggestedActions\` field tells you exactly what to run next.
 
 ## Severity ladder
 
@@ -5134,6 +6252,25 @@ const buildStopHookGroup = () => {
 		}]
 	};
 };
+const FILE_CHANGED_MATCHER = ".aislop/config.yml|.aislop/rules.yml|package.json";
+const buildFileChangedHookGroup = () => {
+	const hashBody = JSON.stringify({
+		command: "aislop hook claude --on-file-changed",
+		matcher: FILE_CHANGED_MATCHER
+	});
+	return {
+		matcher: FILE_CHANGED_MATCHER,
+		hooks: [{
+			type: "command",
+			command: "aislop hook claude --on-file-changed",
+			[AISLOP_SENTINEL_KEY]: {
+				v: 1,
+				managed: true,
+				hash: sentinelHash(hashBody)
+			}
+		}]
+	};
+};
 const renderSettings$1 = (existingRaw, qualityGate) => {
 	let obj = {};
 	if (existingRaw) try {
@@ -5142,6 +6279,7 @@ const renderSettings$1 = (existingRaw, qualityGate) => {
 		obj = {};
 	}
 	let next = upsertHookGroup(obj, "PostToolUse", buildHookGroup$1());
+	next = upsertHookGroup(next, "FileChanged", buildFileChangedHookGroup());
 	if (qualityGate) next = upsertHookGroup(next, "Stop", buildStopHookGroup());
 	else next = removeAislopEntries(next, "Stop").next;
 	return `${JSON.stringify(next, null, 2)}\n`;
@@ -5150,7 +6288,7 @@ const installClaude = (opts) => {
 	const paths = resolveClaudePaths(opts);
 	const result = emptyResult();
 	const nextSettings = renderSettings$1(readIfExists(paths.settings), Boolean(opts.qualityGate));
-	applyContent(result, opts, paths.settings, nextSettings, "register PostToolUse hook");
+	applyContent(result, opts, paths.settings, nextSettings, "register PostToolUse + FileChanged hooks");
 	const mdHash = sentinelHash(AISLOP_MD_BODY);
 	const fenced = upsertMarkdownFence(readIfExists(paths.aislopMd), AISLOP_MD_BODY, mdHash);
 	applyContent(result, opts, paths.aislopMd, fenced.nextContent, "write AISLOP.md rules");
@@ -5180,7 +6318,9 @@ const uninstallClaude = (opts) => {
 		} catch {
 			obj = {};
 		}
-		const stripped = removeAislopEntries(removeAislopEntries(obj, "PostToolUse").next, "Stop").next;
+		const afterPostToolUse = removeAislopEntries(obj, "PostToolUse").next;
+		const afterFileChanged = removeAislopEntries(afterPostToolUse, "FileChanged").next;
+		const stripped = removeAislopEntries(afterFileChanged, "Stop").next;
 		const stillHasHooks = stripped.hooks && typeof stripped.hooks === "object" && Object.keys(stripped.hooks).length > 0;
 		const otherKeys = Object.keys(stripped).filter((k) => k !== "hooks");
 		if (!stillHasHooks && otherKeys.length === 0) applyRemoval(result, opts, paths.settings, null);
@@ -5189,7 +6329,7 @@ const uninstallClaude = (opts) => {
 	if (readIfExists(paths.aislopMd) != null) applyRemoval(result, opts, paths.aislopMd, null);
 	else result.skipped.push(paths.aislopMd);
 	const claudeMd = readIfExists(paths.claudeMd);
-	if (claudeMd != null && claudeMd.includes("@AISLOP.md")) {
+	if (claudeMd?.includes("@AISLOP.md")) {
 		const stripped = claudeMd.split("\n").filter((line) => line.trim() !== "@AISLOP.md").join("\n").replace(/\n{3,}/g, "\n\n").trim();
 		applyRemoval(result, opts, paths.claudeMd, stripped.length === 0 ? null : `${stripped}\n`);
 	} else result.skipped.push(paths.claudeMd);
@@ -5750,7 +6890,9 @@ const hookRun = async (agent, flags) => {
 		process.exit(0);
 	}
 	let exitCode = 0;
-	if (agent === "claude") exitCode = flags?.stop ? await runClaudeStopHook() : await runClaudeHook();
+	if (agent === "claude") if (flags?.onFileChanged) exitCode = await runClaudeFileChangedHook();
+	else if (flags?.stop) exitCode = await runClaudeStopHook();
+	else exitCode = await runClaudeHook();
 	else if (agent === "cursor") exitCode = await runCursorHook();
 	else if (agent === "gemini") exitCode = await runGeminiHook();
 	else {
@@ -5901,8 +7043,11 @@ const registerCallbacks = (hook) => {
 	hook.command("baseline").description("Capture the current project score as the quality-gate baseline").action(async () => {
 		await hookBaseline();
 	});
-	hook.command("claude").description("Internal: Claude Code PostToolUse / Stop callback (reads stdin)").option("--stop", "run in Stop-hook mode for the quality gate").action(async (opts) => {
-		await hookRun("claude", { stop: Boolean(opts.stop) });
+	hook.command("claude").description("Internal: Claude Code PostToolUse / Stop / FileChanged callback (reads stdin)").option("--stop", "run in Stop-hook mode for the quality gate").option("--on-file-changed", "run in FileChanged mode (refresh baseline on watched file change)").action(async (opts) => {
+		await hookRun("claude", {
+			stop: Boolean(opts.stop),
+			onFileChanged: Boolean(opts.onFileChanged)
+		});
 	});
 	hook.command("cursor").description("Internal: Cursor afterFileEdit callback (reads stdin)").action(async () => {
 		await hookRun("cursor");
@@ -5918,6 +7063,83 @@ const registerHookCommand = (program) => {
 	registerCallbacks(hook);
 };
 
+//#endregion
+//#region src/commands/badge.ts
+const GITHUB_REMOTE_RE = /^(?:git@github\.com:|https:\/\/(?:[^@]+@)?github\.com\/)([^/]+)\/([^/.\s]+?)(?:\.git)?\s*$/;
+const renderBadgeOutput = ({ owner, repo, svgUrl, pageUrl }) => {
+	const slug = `${owner}/${repo}`;
+	const markdown = `[![aislop](${svgUrl})](${pageUrl})`;
+	return [
+		``,
+		`  Repository:  ${slug}`,
+		`  Badge URL:   ${svgUrl}`,
+		``,
+		`  Markdown:`,
+		``,
+		`    ${markdown}`,
+		``,
+		`  Drop the line above into your README. The badge auto-updates after every public scan.`,
+		``
+	].join("\n");
+};
+const detectGithubSlugFromGit = (directory) => {
+	let raw;
+	try {
+		raw = execSync("git remote get-url origin", {
+			cwd: path.resolve(directory),
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		});
+	} catch {
+		return null;
+	}
+	const match = raw.trim().match(GITHUB_REMOTE_RE);
+	if (!match) return null;
+	const owner = match[1];
+	const repo = match[2];
+	if (!owner || !repo) return null;
+	return {
+		owner,
+		repo
+	};
+};
+const badgeCommand = async (options = {}) => {
+	let owner = options.owner?.trim();
+	let repo = options.repo?.trim();
+	if (!owner || !repo) {
+		const detected = detectGithubSlugFromGit(options.directory ?? ".");
+		if (!detected) throw new Error("Could not detect a GitHub remote. Run from a repo with `git remote get-url origin` set, or pass --owner and --repo.");
+		owner ??= detected.owner;
+		repo ??= detected.repo;
+	}
+	const svgUrl = `https://badges.scanaislop.com/score/${owner}/${repo}.svg`;
+	const pageUrl = `https://scanaislop.com/${owner}/${repo}`;
+	const output = renderBadgeOutput({
+		owner,
+		repo,
+		svgUrl,
+		pageUrl
+	});
+	if (options.json) process.stdout.write(JSON.stringify({
+		owner,
+		repo,
+		svgUrl,
+		pageUrl
+	}) + "\n");
+	else process.stdout.write(output);
+	return {
+		owner,
+		repo,
+		svgUrl,
+		pageUrl,
+		output
+	};
+};
+
 //#endregion
 //#region src/ui/symbols.ts
 const TTY = {
@@ -6334,7 +7556,7 @@ const renderCleanRun = (input, deps = {}) => {
 
 //#endregion
 //#region src/version.ts
-const APP_VERSION = "0.6.2";
+const APP_VERSION = "0.8.0";
 
 //#endregion
 //#region src/utils/telemetry.ts
@@ -6489,6 +7711,7 @@ const scanCommand = async (directory, config, options) => {
 	const engineConfig = {
 		quality: config.quality,
 		security: config.security,
+		lint: config.lint,
 		architectureRulesPath: config.engines.architecture ? rulesPath : void 0
 	};
 	const gridRows = ALL_ENGINE_NAMES.filter((engine) => config.engines[engine] !== false).map((engine) => ({
@@ -6556,7 +7779,7 @@ const scanCommand = async (directory, config, options) => {
 		});
 	}
 	if (options.json) {
-		const { buildJsonOutput } = await import("./json-B51etWTw.js");
+		const { buildJsonOutput } = await import("./json-BbMwrgyd.js");
 		const jsonOut = buildJsonOutput(results, scoreResult, projectInfo.sourceFileCount, elapsedMs);
 		console.log(JSON.stringify(jsonOut, null, 2));
 		return { exitCode };
@@ -6767,16 +7990,29 @@ const planFormat = (ctx) => {
 		skipReason: "no supported language"
 	};
 };
-const planLint = (ctx) => {
-	const { languages, frameworks, installedTools } = ctx.projectInfo;
-	if (frameworks.includes("expo")) return {
-		tool: "expo-doctor + oxlint (bundled)",
+const findLocalTsc = (root) => {
+	const candidate = path.join(root, "node_modules", ".bin", "tsc");
+	return fs.existsSync(candidate) ? candidate : null;
+};
+const withTypecheckSuffix = (baseTool, ctx) => {
+	if (!ctx.config.lint?.typecheck) return {
+		tool: baseTool,
 		status: "ok"
 	};
-	if (hasJsLike(languages)) return {
-		tool: "oxlint (bundled)",
+	if (findLocalTsc(ctx.rootDirectory)) return {
+		tool: `${baseTool} + tsc`,
 		status: "ok"
 	};
+	return {
+		tool: `${baseTool} + tsc not found`,
+		status: "missing",
+		remediation: "Install TypeScript locally (pnpm add -D typescript), or set lint.typecheck: false in .aislop/config.yml."
+	};
+};
+const planLint = (ctx) => {
+	const { languages, frameworks, installedTools } = ctx.projectInfo;
+	if (frameworks.includes("expo")) return withTypecheckSuffix("expo-doctor + oxlint (bundled)", ctx);
+	if (hasJsLike(languages)) return withTypecheckSuffix("oxlint (bundled)", ctx);
 	return firstMatching(languages, installedTools, LINT_SPECS) ?? {
 		tool: "no linter",
 		status: "skipped",
@@ -7371,6 +8607,212 @@ const applyEditsAndCollapse = (lines, linesToRemove, lineReplacements) => {
 	return collapsed.join("\n");
 };
 
+//#endregion
+//#region src/engines/ai-slop/duplicate-imports-fix.ts
+const JS_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const IMPORT_FROM_RE = /^\s*import\s+(.*?)\s+from\s+["']([^"']+)["']\s*;?\s*$/;
+const SIDE_EFFECT_RE = /^\s*import\s+["']([^"']+)["']\s*;?\s*$/;
+const parseNamedClause = (clause) => {
+	const inner = clause.trim().slice(1, -1).trim();
+	if (inner.length === 0) return [];
+	const items = [];
+	for (const part of inner.split(",")) {
+		const trimmed = part.trim();
+		if (!trimmed) continue;
+		let isType = false;
+		let working = trimmed;
+		if (/^type\s+/.test(working)) {
+			isType = true;
+			working = working.replace(/^type\s+/, "");
+		}
+		const aliasMatch = working.match(/^(\w+)\s+as\s+(\w+)$/);
+		if (aliasMatch) {
+			items.push({
+				name: aliasMatch[1],
+				alias: aliasMatch[2],
+				isType
+			});
+			continue;
+		}
+		if (/^\w+$/.test(working)) items.push({
+			name: working,
+			isType
+		});
+	}
+	return items;
+};
+const parseImportClause = (clause) => {
+	let rest = clause.trim();
+	let isTypeOnly = false;
+	if (/^type\s+/.test(rest)) {
+		isTypeOnly = true;
+		rest = rest.replace(/^type\s+/, "");
+	}
+	const out = {
+		named: [],
+		isTypeOnly
+	};
+	const defMatch = rest.match(/^([A-Za-z_$][\w$]*)\s*(?:,\s*(.+))?$/);
+	if (defMatch && !rest.startsWith("{") && !rest.startsWith("*")) {
+		out.default = defMatch[1];
+		rest = defMatch[2]?.trim() ?? "";
+	}
+	if (rest.startsWith("*")) {
+		const nsMatch = rest.match(/^\*\s+as\s+(\w+)/);
+		if (nsMatch) out.namespace = nsMatch[1];
+		return out;
+	}
+	if (rest.startsWith("{")) out.named = parseNamedClause(rest);
+	return out;
+};
+const parseImportLine = (line, lineIndex) => {
+	const sideEffect = line.match(SIDE_EFFECT_RE);
+	if (sideEffect) return {
+		lineIndex,
+		module: sideEffect[1],
+		named: [],
+		isTypeOnly: false,
+		isSideEffect: true
+	};
+	const m = line.match(IMPORT_FROM_RE);
+	if (!m) return null;
+	return {
+		lineIndex,
+		module: m[2],
+		isSideEffect: false,
+		...parseImportClause(m[1])
+	};
+};
+const formatNamed = (n, stripType) => {
+	const prefix = n.isType && !stripType ? "type " : "";
+	const suffix = n.alias ? ` as ${n.alias}` : "";
+	return `${prefix}${n.name}${suffix}`;
+};
+const mergeImports = (group) => {
+	if (group.some((s) => s.isSideEffect)) return null;
+	if (group.some((s) => s.namespace !== void 0)) return null;
+	if (group.some((s) => s.isTypeOnly && s.default !== void 0)) return null;
+	const defaults = group.map((s) => s.default).filter((d) => d !== void 0);
+	const uniqueDefaults = Array.from(new Set(defaults));
+	if (uniqueDefaults.length > 1) return null;
+	const defaultName = uniqueDefaults[0];
+	const merged = /* @__PURE__ */ new Map();
+	for (const stmt of group) for (const nm of stmt.named) {
+		const key = nm.alias ?? nm.name;
+		const isType = nm.isType || stmt.isTypeOnly;
+		const existing = merged.get(key);
+		if (!existing) merged.set(key, {
+			...nm,
+			isType
+		});
+		else existing.isType = existing.isType && isType;
+	}
+	const insertionOrder = Array.from(merged.values());
+	const namedList = [...insertionOrder.filter((n) => !n.isType), ...insertionOrder.filter((n) => n.isType)];
+	const allTypeOnly = namedList.length > 0 && namedList.every((n) => n.isType);
+	const module = group[0].module;
+	if (!defaultName && namedList.length === 0) return null;
+	if (!defaultName && allTypeOnly) return `import type { ${namedList.map((n) => formatNamed(n, true)).join(", ")} } from "${module}";`;
+	const parts = [];
+	if (defaultName) parts.push(defaultName);
+	if (namedList.length > 0) {
+		const items = namedList.map((n) => formatNamed(n, false)).join(", ");
+		parts.push(`{ ${items} }`);
+	}
+	return `import ${parts.join(", ")} from "${module}";`;
+};
+const fixDuplicateImports = async (context) => {
+	const files = getSourceFiles(context);
+	for (const filePath of files) {
+		if (!JS_EXTENSIONS.has(path.extname(filePath))) continue;
+		if (isAutoGenerated(filePath)) continue;
+		let content;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const lines = content.split("\n");
+		const imports = [];
+		for (let i = 0; i < lines.length; i++) {
+			const stmt = parseImportLine(lines[i], i);
+			if (stmt) imports.push(stmt);
+		}
+		if (imports.length < 2) continue;
+		const groups = /* @__PURE__ */ new Map();
+		for (const stmt of imports) {
+			const list = groups.get(stmt.module) ?? [];
+			list.push(stmt);
+			groups.set(stmt.module, list);
+		}
+		const linesToRemove = /* @__PURE__ */ new Set();
+		const replacements = /* @__PURE__ */ new Map();
+		let modified = false;
+		for (const group of groups.values()) {
+			if (group.length < 2) continue;
+			const merged = mergeImports(group);
+			if (!merged) continue;
+			replacements.set(group[0].lineIndex, merged);
+			for (const stmt of group.slice(1)) linesToRemove.add(stmt.lineIndex);
+			modified = true;
+		}
+		if (!modified) continue;
+		const next = [...lines];
+		for (const [idx, replacement] of replacements) next[idx] = replacement;
+		const sortedRemove = Array.from(linesToRemove).sort((a, b) => b - a);
+		for (const idx of sortedRemove) next.splice(idx, 1);
+		fs.writeFileSync(filePath, next.join("\n"));
+	}
+};
+
+//#endregion
+//#region src/engines/ai-slop/narrative-comments-fix.ts
+const fixNarrativeComments = async (context) => {
+	const diagnostics = await detectNarrativeComments(context);
+	if (diagnostics.length === 0) return;
+	const byFile = /* @__PURE__ */ new Map();
+	for (const d of diagnostics) {
+		const abs = d.filePath.startsWith("/") ? d.filePath : `${context.rootDirectory}/${d.filePath}`;
+		const list = byFile.get(abs) ?? [];
+		list.push(d);
+		byFile.set(abs, list);
+	}
+	for (const [filePath, diags] of byFile) {
+		const syntax = getCommentSyntax(path.extname(filePath));
+		if (!syntax) continue;
+		let content;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const lines = content.split("\n");
+		const blocks = collectBlocks(lines, syntax);
+		const toRemove = /* @__PURE__ */ new Set();
+		for (const d of diags) {
+			const block = blocks.find((b) => b.startLine === d.line);
+			if (!block) continue;
+			for (let ln = block.startLine; ln <= block.endLine; ln += 1) toRemove.add(ln);
+			const prev = block.startLine - 1;
+			const next = block.endLine + 1;
+			const prevIsBlank = prev >= 1 && lines[prev - 1]?.trim() === "";
+			const nextIsBlank = next <= lines.length && lines[next - 1]?.trim() === "";
+			if (prevIsBlank && nextIsBlank) toRemove.add(prev);
+		}
+		const kept = [];
+		for (let i = 0; i < lines.length; i += 1) if (!toRemove.has(i + 1)) kept.push(lines[i]);
+		const newContent = kept.join("\n");
+		if (newContent !== content) fs.writeFileSync(filePath, newContent);
+	}
+};
+
 //#endregion
 //#region src/engines/ai-slop/unused-imports-fix.ts
 const fixUnusedImports = async (context) => {
@@ -7392,9 +8834,9 @@ const fixUnusedImports = async (context) => {
 		for (const [lineNo, syms] of symbolsByLine) {
 			const lineIdx = lineNo - 1;
 			const allUnused = syms.every((s) => unusedNames.has(s.name));
-			const importSpan = JS_EXTENSIONS.has(analysis.ext) ? getJsImportSpan(lines, lineIdx) : [lineIdx];
+			const importSpan = JS_EXTENSIONS$1.has(analysis.ext) ? getJsImportSpan(lines, lineIdx) : [lineIdx];
 			if (allUnused) for (const idx of importSpan) linesToRemove.add(idx);
-			else if (JS_EXTENSIONS.has(analysis.ext)) rewriteJsImportSpan(lines, importSpan, syms, unusedNames);
+			else if (JS_EXTENSIONS$1.has(analysis.ext)) rewriteJsImportSpan(lines, importSpan, syms, unusedNames);
 			else if (PY_EXTENSIONS.has(analysis.ext)) rewritePyImportLine(lines, lineIdx, syms, unusedNames);
 		}
 		if (linesToRemove.size === 0 && unused.length === 0) continue;
@@ -8127,6 +9569,7 @@ const hasJsOrTs = (projectInfo) => projectInfo.languages.includes("typescript")
 const runAiSlopSteps = async (deps) => {
 	if (!deps.config.engines["ai-slop"]) return;
 	await deps.runStep("Unused imports", () => detectUnusedImports(deps.context), () => fixUnusedImports(deps.context));
+	await deps.runStep("Duplicate imports", () => detectDuplicateImports(deps.context), () => fixDuplicateImports(deps.context));
 	const detectFixableSlop = async () => {
 		const [comments, dead, narrative] = await Promise.all([
 			detectTrivialComments(deps.context),
@@ -8232,7 +9675,8 @@ const createEngineContext = (rootDirectory, projectInfo, config) => ({
 	installedTools: projectInfo.installedTools,
 	config: {
 		quality: config.quality,
-		security: config.security
+		security: config.security,
+		lint: config.lint
 	}
 });
 const fixCommand = async (directory, config, options = {
@@ -8295,6 +9739,7 @@ const fixCommand = async (directory, config, options = {
 	const engineConfig = {
 		quality: config.quality,
 		security: config.security,
+		lint: config.lint,
 		architectureRulesPath: config.engines.architecture ? rulesPath : void 0
 	};
 	rail.start("Verifying results");
@@ -8599,8 +10044,10 @@ const buildRulesRender = (input) => {
 const AI_SLOP_FIXABLE = new Set([
 	"ai-slop/trivial-comment",
 	"ai-slop/unused-import",
-	"ai-slop/narrative-comment"
+	"ai-slop/narrative-comment",
+	"ai-slop/duplicate-import"
 ]);
+const AI_SLOP_ERRORS = new Set(["ai-slop/hallucinated-import"]);
 const BUILTIN_RULES = [
 	{
 		engine: "format",
@@ -8621,7 +10068,8 @@ const BUILTIN_RULES = [
 			"ruff/*",
 			"go/*",
 			"clippy/*",
-			"rubocop/*"
+			"rubocop/*",
+			"typescript/*"
 		]
 	},
 	{
@@ -8657,7 +10105,16 @@ const BUILTIN_RULES = [
 			"ai-slop/unsafe-type-assertion",
 			"ai-slop/double-type-assertion",
 			"ai-slop/ts-directive",
-			"ai-slop/narrative-comment"
+			"ai-slop/narrative-comment",
+			"ai-slop/duplicate-import",
+			"ai-slop/python-bare-except",
+			"ai-slop/python-broad-except",
+			"ai-slop/python-mutable-default",
+			"ai-slop/python-print-debug",
+			"ai-slop/go-library-panic",
+			"ai-slop/rust-non-test-unwrap",
+			"ai-slop/rust-todo-stub",
+			"ai-slop/hallucinated-import"
 		]
 	},
 	{
@@ -8688,7 +10145,7 @@ const toRuleEntry = (engine, ruleId) => {
 	if (engine === "ai-slop") return {
 		id: ruleId,
 		engine,
-		severity: "warning",
+		severity: AI_SLOP_ERRORS.has(ruleId) ? "error" : "warning",
 		fixable: AI_SLOP_FIXABLE.has(ruleId)
 	};
 	return {
@@ -8980,6 +10437,20 @@ program.command("ci [directory]").description("CI-friendly JSON output with exit
 program.command("rules [directory]").description("List all available rules").action(async (directory = ".") => {
 	await rulesCommand(directory);
 });
+program.command("badge [directory]").description("Print the public score badge URL + README markdown for this repo").option("--owner <owner>", "GitHub owner (auto-detected from git remote if omitted)").option("--repo <repo>", "GitHub repo name (auto-detected from git remote if omitted)").option("--json", "emit machine-readable JSON instead of the rendered output").action(async (directory = ".", _flags, command) => {
+	const flags = command.optsWithGlobals();
+	try {
+		await badgeCommand({
+			directory,
+			owner: flags.owner,
+			repo: flags.repo,
+			json: Boolean(flags.json)
+		});
+	} catch (err) {
+		process.stderr.write(`${err?.message ?? "Failed to print badge"}\n`);
+		process.exit(1);
+	}
+});
 registerHookCommand(program);
 const main = async () => {
 	await program.parseAsync();
@@ -8988,4 +10459,4 @@ const main = async () => {
 main();
 
 //#endregion
-export { ENGINE_INFO as n, APP_VERSION as t };
+export { ENGINE_INFO as n, runSubprocess as r, APP_VERSION as t };