aislop 0.8.3 → 0.9.0

package/dist/cli.js

@@ -4,14 +4,14 @@ import { Command } from "commander";
 import os from "node:os";
 import fs from "node:fs";
 import path from "node:path";
+import crypto, { randomUUID } from "node:crypto";
+import { performance } from "node:perf_hooks";
 import YAML from "yaml";
 import { z } from "zod/v4";
-import { performance } from "node:perf_hooks";
 import { execSync, spawn, spawnSync } from "node:child_process";
 import micromatch from "micromatch";
 import { fileURLToPath } from "node:url";
 import ts from "typescript";
-import crypto from "node:crypto";
 import { isCancel, multiselect, select, text } from "@clack/prompts";
 import pc from "picocolors";
 import wcwidth from "wcwidth";
@@ -32,6 +32,366 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 
+//#endregion
+//#region src/version.ts
+const APP_VERSION = "0.9.0";
+
+//#endregion
+//#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";
+};
+
+//#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;
+};
+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: input.event,
+		distinct_id: cachedInstallId,
+		properties: clean,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const request = fetch(`${POSTHOG_HOST}/capture/`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(payload),
+		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 buildHookScanCompletedProps = (input) => {
+	const props = {
+		agent: input.agent,
+		score: input.score,
+		score_bucket: scoreBucket(input.score),
+		finding_count: input.findingCount,
+		file_count_bucket: fileCountBucket(input.fileCount)
+	};
+	if (typeof input.scoreDelta === "number") props.score_delta = input.scoreDelta;
+	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
 //#region src/hooks/feedback.ts
 const fingerprintFinding = (f) => `${f.file}:${f.line}:${f.ruleId}`;
@@ -4636,7 +4996,7 @@ const lintEngine = {
 		const promises = [];
 		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.config.lint.typecheck) promises.push(import("./typecheck-wVSohmOX.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));
@@ -5855,6 +6215,16 @@ const runClaudeHook = async (deps = {}) => {
 			score: baseline.score,
 			findingFingerprints: baseline.findingFingerprints
 		} : void 0);
+		track({
+			event: "hook_scan_completed",
+			properties: buildHookScanCompletedProps({
+				agent: "claude",
+				score,
+				scoreDelta: baseline ? score - baseline.score : null,
+				findingCount: diagnostics.length,
+				fileCount: files.length
+			})
+		});
 		const envelope = renderClaudeOutput(JSON.stringify(feedback));
 		write(JSON.stringify(envelope));
 		return 0;
@@ -5986,6 +6356,15 @@ const runCursorHook = async (deps = {}) => {
 	try {
 		const { diagnostics, score, rootDirectory } = await runScopedScan(cwd, files);
 		const feedback = buildFeedback(diagnostics, score, rootDirectory);
+		track({
+			event: "hook_scan_completed",
+			properties: buildHookScanCompletedProps({
+				agent: "cursor",
+				score,
+				findingCount: diagnostics.length,
+				fileCount: files.length
+			})
+		});
 		const serialized = JSON.stringify(feedback);
 		write(JSON.stringify(renderCursorOutput(serialized)));
 		writeErr(`${serialized}\n`);
@@ -6036,6 +6415,15 @@ const runGeminiHook = async (deps = {}) => {
 	try {
 		const { diagnostics, score, rootDirectory } = await runScopedScan(cwd, files);
 		const feedback = buildFeedback(diagnostics, score, rootDirectory);
+		track({
+			event: "hook_scan_completed",
+			properties: buildHookScanCompletedProps({
+				agent: "gemini",
+				score,
+				findingCount: diagnostics.length,
+				fileCount: files.length
+			})
+		});
 		write(JSON.stringify(renderGeminiOutput(JSON.stringify(feedback))));
 		return 0;
 	} catch {
@@ -7050,12 +7438,18 @@ const registerInstall = (hook) => {
 	install.action(async (positional, opts) => {
 		const agents = await pickAgents("install", opts, positional);
 		if (agents === null || agents.length === 0) return;
-		await hookInstall({
-			agents,
-			scope: resolveScope(opts),
-			dryRun: Boolean(opts.dryRun),
-			yes: Boolean(opts.yes),
-			qualityGate: Boolean(opts.qualityGate)
+		await withCommandLifecycle({
+			command: "hook_install",
+			config: loadConfig(process.cwd()).telemetry
+		}, async () => {
+			await hookInstall({
+				agents,
+				scope: resolveScope(opts),
+				dryRun: Boolean(opts.dryRun),
+				yes: Boolean(opts.yes),
+				qualityGate: Boolean(opts.qualityGate)
+			});
+			return { exitCode: 0 };
 		});
 	});
 };
@@ -7065,21 +7459,39 @@ const registerUninstall = (hook) => {
 	uninstall.action(async (positional, opts) => {
 		const agents = await pickAgents("uninstall", opts, positional);
 		if (agents === null || agents.length === 0) return;
-		await hookUninstall({
-			agents,
-			scope: resolveScope(opts),
-			dryRun: Boolean(opts.dryRun),
-			yes: true,
-			qualityGate: false
+		await withCommandLifecycle({
+			command: "hook_uninstall",
+			config: loadConfig(process.cwd()).telemetry
+		}, async () => {
+			await hookUninstall({
+				agents,
+				scope: resolveScope(opts),
+				dryRun: Boolean(opts.dryRun),
+				yes: true,
+				qualityGate: false
+			});
+			return { exitCode: 0 };
 		});
 	});
 };
 const registerCallbacks = (hook) => {
 	hook.command("status").description("Show which agent hooks are installed").action(async () => {
-		await hookStatus();
+		await withCommandLifecycle({
+			command: "hook_status",
+			config: loadConfig(process.cwd()).telemetry
+		}, async () => {
+			await hookStatus();
+			return { exitCode: 0 };
+		});
 	});
 	hook.command("baseline").description("Capture the current project score as the quality-gate baseline").action(async () => {
-		await hookBaseline();
+		await withCommandLifecycle({
+			command: "hook_baseline",
+			config: loadConfig(process.cwd()).telemetry
+		}, async () => {
+			await hookBaseline();
+			return { exitCode: 0 };
+		});
 	});
 	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", {
@@ -7592,73 +8004,6 @@ const renderCleanRun = (input, deps = {}) => {
 	return `\n ${parts.join(`  ${sep}  `)}\n`;
 };
 
-//#endregion
-//#region src/version.ts
-const APP_VERSION = "0.8.3";
-
-//#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) => {
-	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)}`;
-};
-/** Pending telemetry request — kept alive so Node doesn't exit before it completes. */
-let pendingRequest = null;
-const trackEvent = (event) => {
-	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
-		},
-		timestamp: (/* @__PURE__ */ new Date()).toISOString()
-	};
-	pendingRequest = fetch(`${POSTHOG_HOST}/capture/`, {
-		method: "POST",
-		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify(payload),
-		signal: AbortSignal.timeout(3e3)
-	}).then(() => {}).catch(() => {});
-};
-const flushTelemetry = async () => {
-	if (pendingRequest) {
-		await pendingRequest;
-		pendingRequest = null;
-	}
-};
-
 //#endregion
 //#region src/commands/scan.ts
 const shouldUseSpinner = () => Boolean(process.stderr.isTTY) && process.env.CI !== "true" && process.env.CI !== "1";
@@ -7716,7 +8061,6 @@ const buildScanRender = (input) => {
 	}, 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}`;
@@ -7730,9 +8074,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);
@@ -7799,28 +8152,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-BbMwrgyd.js");
+		const { buildJsonOutput } = await import("./json-OIzja7OM.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";
@@ -7837,7 +8189,7 @@ const scanCommand = async (directory, config, options) => {
 		includeHeader: showHeader,
 		printBrand: options.printBrand
 	}));
-	return { exitCode };
+	return completion;
 };
 
 //#endregion
@@ -9785,15 +10137,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,
@@ -9830,12 +10190,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 = {
@@ -9858,7 +10212,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"
@@ -9887,12 +10243,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
@@ -10375,6 +10750,13 @@ const interactiveCommand = async (directory, config) => {
 //#region src/cli.ts
 process.on("SIGINT", () => process.exit(0));
 process.on("SIGTERM", () => process.exit(0));
+const fireInstalledOnce = () => {
+	if (isTelemetryDisabled(loadConfig(process.cwd()).telemetry)) return;
+	if (ensureInstallId(resolveInstallIdPath()).created) track({
+		event: "cli_installed",
+		config: loadConfig(process.cwd()).telemetry
+	});
+};
 const excludeParser = (value, previous = []) => {
 	const parts = value.split(",").map((v) => v.trim()).filter(Boolean);
 	return [...previous, ...parts];
@@ -10523,10 +10905,22 @@ fixProgram.action(async (directory = ".", _flags, command) => {
 	});
 });
 program.command("init [directory]").description("Initialize aislop config in project").action(async (directory = ".") => {
-	await initCommand(directory);
+	await withCommandLifecycle({
+		command: "init",
+		config: loadConfig(directory).telemetry
+	}, async () => {
+		await initCommand(directory);
+		return { exitCode: 0 };
+	});
 });
 program.command("doctor [directory]").description("Check installed tools and environment").action(async (directory = ".") => {
-	await doctorCommand(directory);
+	await withCommandLifecycle({
+		command: "doctor",
+		config: loadConfig(directory).telemetry
+	}, async () => {
+		await doctorCommand(directory);
+		return { exitCode: 0 };
+	});
 });
 program.command("ci [directory]").description("CI-friendly JSON output with exit codes").option("--human", "render the human-friendly scan design instead of JSON").action(async (directory = ".", _flags, command) => {
 	const flags = command.optsWithGlobals();
@@ -10537,16 +10931,28 @@ 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);
+	await withCommandLifecycle({
+		command: "rules",
+		config: loadConfig(directory).telemetry
+	}, async () => {
+		await rulesCommand(directory);
+		return { exitCode: 0 };
+	});
 });
 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)
+		await withCommandLifecycle({
+			command: "badge",
+			config: loadConfig(directory).telemetry
+		}, async () => {
+			await badgeCommand({
+				directory,
+				owner: flags.owner,
+				repo: flags.repo,
+				json: Boolean(flags.json)
+			});
+			return { exitCode: 0 };
 		});
 	} catch (err) {
 		process.stderr.write(`${err?.message ?? "Failed to print badge"}\n`);
@@ -10555,10 +10961,11 @@ program.command("badge [directory]").description("Print the public score badge U
 });
 registerHookCommand(program);
 const main = async () => {
+	fireInstalledOnce();
 	await program.parseAsync();
 	await flushTelemetry();
 };
 main();
 
 //#endregion
-export { ENGINE_INFO as n, runSubprocess as r, APP_VERSION as t };
+export { runSubprocess as n, APP_VERSION as r, ENGINE_INFO as t };