@docker-doctor/cli 0.2.1 → 0.3.1

package/dist/cli.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const require_src = require('./src-O8FXMq8O.cjs');
+const require_src = require('./src-38C8Tk2b.cjs');
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_src.__toESM(node_fs_promises, 1);
 let node_path = require("node:path");
@@ -9,10 +9,650 @@ node_os = require_src.__toESM(node_os, 1);
 let node_readline = require("node:readline");
 node_readline = require_src.__toESM(node_readline, 1);
 let node_timers_promises = require("node:timers/promises");
-let chalk = require("chalk");
-chalk = require_src.__toESM(chalk, 1);
+let agent_install = require("agent-install");
+let node_process = require("node:process");
+node_process = require_src.__toESM(node_process, 1);
+let node_tty = require("node:tty");
+node_tty = require_src.__toESM(node_tty, 1);
 let commander = require("commander");
+let node_child_process = require("node:child_process");
+let node_fs = require("node:fs");
+node_fs = require_src.__toESM(node_fs, 1);
 
+//#region ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	}
+};
+const modifierNames = Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+const colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+			group[styleName] = styles$1[styleName];
+			codes.set(style[0], style[1]);
+		}
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles$1, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles$1.color.close = "\x1B[39m";
+	styles$1.bgColor.close = "\x1B[49m";
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false
+		}
+	});
+	return styles$1;
+}
+const ansiStyles = assembleStyles();
+
+//#endregion
+//#region ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : node_process.default.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = node_process.default;
+let flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function envForceColor() {
+	if ("FORCE_COLOR" in env) {
+		if (env.FORCE_COLOR === "true") return 1;
+		if (env.FORCE_COLOR === "false") return 0;
+		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor || 0;
+	if (env.TERM === "dumb") return min;
+	if (node_process.default.platform === "win32") {
+		const osRelease = node_os.default.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (env.COLORTERM === "truecolor") return 3;
+	if (env.TERM === "xterm-kitty") return 3;
+	if (env.TERM === "xterm-ghostty") return 3;
+	if (env.TERM === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+		switch (env.TERM_PROGRAM) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(color)?$/i.test(env.TERM)) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(_supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	}));
+}
+const supportsColor = {
+	stdout: createSupportsColor({ isTTY: node_tty.default.isatty(1) }),
+	stderr: createSupportsColor({ isTTY: node_tty.default.isatty(2) })
+};
+
+//#endregion
+//#region ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const gotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/index.js
+const { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
+const GENERATOR = Symbol("GENERATOR");
+const STYLER = Symbol("STYLER");
+const IS_EMPTY = Symbol("IS_EMPTY");
+const levelMapping = [
+	"ansi",
+	"ansi",
+	"ansi256",
+	"ansi16m"
+];
+const styles = Object.create(null);
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === void 0 ? colorLevel : options.level;
+};
+const chalkFactory = (options) => {
+	const chalk = (...strings) => strings.join(" ");
+	applyOptions(chalk, options);
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+	return chalk;
+};
+function createChalk(options) {
+	return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+	const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+	Object.defineProperty(this, styleName, { value: builder });
+	return builder;
+} };
+styles.visible = { get() {
+	const builder = createBuilder(this, this[STYLER], true);
+	Object.defineProperty(this, "visible", { value: builder });
+	return builder;
+} };
+const getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === "rgb") {
+		if (level === "ansi16m") return ansiStyles[type].ansi16m(...arguments_);
+		if (level === "ansi256") return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+	if (model === "hex") return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
+	return ansiStyles[type][model](...arguments_);
+};
+for (const model of [
+	"rgb",
+	"hex",
+	"ansi256"
+]) {
+	styles[model] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+	const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+}
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		}
+	}
+});
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === void 0) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+	Object.setPrototypeOf(builder, proto);
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+	return builder;
+};
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+	let styler = self[STYLER];
+	if (styler === void 0) return string;
+	const { openAll, closeAll } = styler;
+	if (string.includes("\x1B")) while (styler !== void 0) {
+		string = stringReplaceAll(string, styler.close, styler.open);
+		styler = styler.parent;
+	}
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles);
+const chalk = createChalk();
+const chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+
+//#endregion
+//#region src/agents/clipboard.ts
+const getClipboardCommands = () => {
+	if (process.platform === "darwin") return [{
+		args: [],
+		command: "pbcopy"
+	}];
+	if (process.platform === "win32") return [{
+		args: [],
+		command: "clip"
+	}];
+	return [
+		{
+			args: [],
+			command: "wl-copy"
+		},
+		{
+			args: ["-selection", "clipboard"],
+			command: "xclip"
+		},
+		{
+			args: ["--clipboard", "--input"],
+			command: "xsel"
+		}
+	];
+};
+const tryCopy = ({ command, args }, text) => new Promise((resolve) => {
+	const child = (0, node_child_process.spawn)(command, args, { stdio: [
+		"pipe",
+		"ignore",
+		"ignore"
+	] });
+	child.once("error", () => {
+		resolve(false);
+	});
+	child.once("exit", (code) => {
+		resolve(code === 0);
+	});
+	child.stdin.end(text);
+});
+const tryCommands = async (commands, text) => {
+	const [first, ...rest] = commands;
+	if (!first) return false;
+	if (await tryCopy(first, text)) return true;
+	return tryCommands(rest, text);
+};
+const copyToClipboard = (text) => tryCommands(getClipboardCommands(), text);
+
+//#endregion
+//#region src/agents/diagnostics-dir.ts
+const DIAGNOSTICS_DIR_NAME = ".docker-doctor";
+const UNSAFE_FILE_CHARS = /[^a-z0-9-]+/giu;
+const ruleFileName = (rule) => {
+	return `${(rule.split("/").at(-1) ?? rule).replace(UNSAFE_FILE_CHARS, "-")}.txt`;
+};
+const groupDiagnosticsByRule = (diagnostics) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const diagnostic of diagnostics) {
+		const group = groups.get(diagnostic.rule);
+		if (group) group.push(diagnostic);
+		else groups.set(diagnostic.rule, [diagnostic]);
+	}
+	return groups;
+};
+const writeDiagnosticsDirectory = async (diagnostics, report, rootDir) => {
+	const dir = node_path.default.join(rootDir, DIAGNOSTICS_DIR_NAME);
+	await node_fs_promises.default.rm(dir, {
+		force: true,
+		recursive: true
+	});
+	await node_fs_promises.default.mkdir(dir, { recursive: true });
+	await node_fs_promises.default.writeFile(node_path.default.join(dir, "diagnostics.json"), JSON.stringify(report, null, 2), "utf-8");
+	const writes = [];
+	for (const [rule, ruleDiagnostics] of groupDiagnosticsByRule(diagnostics)) {
+		const [first] = ruleDiagnostics;
+		const lines = [
+			`${rule} (${first.severity})`,
+			first.message,
+			`Fix: ${first.help}`,
+			"",
+			...ruleDiagnostics.map((d) => `${d.file}${d.line === void 0 ? "" : `:${d.line}`}`),
+			""
+		];
+		writes.push(node_fs_promises.default.writeFile(node_path.default.join(dir, ruleFileName(rule)), lines.join("\n"), "utf-8"));
+	}
+	await Promise.all(writes);
+};
+const ensureGitignoreEntry = async (rootDir) => {
+	const gitignorePath = node_path.default.join(rootDir, ".gitignore");
+	let existing = null;
+	try {
+		existing = await node_fs_promises.default.readFile(gitignorePath, "utf-8");
+	} catch {
+		existing = null;
+	}
+	if (existing !== null) {
+		if (existing.split(/\r?\n/u).some((line) => [
+			".docker-doctor",
+			`${".docker-doctor"}/`,
+			`/${".docker-doctor"}`,
+			`/${".docker-doctor"}/`
+		].includes(line.trim()))) return;
+		const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
+		await node_fs_promises.default.writeFile(gitignorePath, `${existing}${separator}${DIAGNOSTICS_DIR_NAME}/\n`, "utf-8");
+		return;
+	}
+	try {
+		await node_fs_promises.default.access(node_path.default.join(rootDir, ".git"));
+	} catch {
+		return;
+	}
+	await node_fs_promises.default.writeFile(gitignorePath, `${DIAGNOSTICS_DIR_NAME}/\n`, "utf-8");
+};
+
+//#endregion
+//#region src/agents/handoff-payload.ts
+const MAX_FILES_PER_RULE = 5;
+const SEVERITY_RANK = {
+	error: 0,
+	info: 2,
+	warning: 1
+};
+const SEVERITY_LABEL = {
+	error: "ERROR",
+	info: "INFO",
+	warning: "WARN"
+};
+const buildHandoffPayload = (input) => {
+	const groups = [...groupDiagnosticsByRule(input.diagnostics).entries()].toSorted(([, a], [, b]) => {
+		const rankDelta = SEVERITY_RANK[a[0].severity] - SEVERITY_RANK[b[0].severity];
+		return rankDelta === 0 ? b.length - a.length : rankDelta;
+	});
+	const issueWord = groups.length === 1 ? "issue" : "issues";
+	const lines = [`Fix the ${groups.length} Docker Doctor ${issueWord} in ${input.projectName}.`, ""];
+	for (const [index, [rule, ruleDiagnostics]] of groups.entries()) {
+		const [first] = ruleDiagnostics;
+		const category = require_src.findRule(rule)?.category ?? "General";
+		const countBadge = ruleDiagnostics.length > 1 ? ` (×${ruleDiagnostics.length})` : "";
+		lines.push(`${index + 1}. ${SEVERITY_LABEL[first.severity]} ${category}: ${first.message} [${rule}]${countBadge}`, `   Fix: ${first.help}`);
+		const files = [...new Set(ruleDiagnostics.map((d) => d.file))];
+		for (const file of files.slice(0, MAX_FILES_PER_RULE)) {
+			const firstSite = ruleDiagnostics.find((d) => d.file === file && d.line !== void 0);
+			lines.push(`   - ${file}${firstSite ? `:${firstSite.line}` : ""}`);
+		}
+		const remaining = files.length - MAX_FILES_PER_RULE;
+		if (remaining > 0) lines.push(`   - +${remaining} more files`);
+	}
+	lines.push("", `Full report (diagnostics.json + a .txt per rule): ${DIAGNOSTICS_DIR_NAME}/`, "", "Read each file and fix the root cause — don't suppress or silence the rule.", "When you're done, re-run `npx @docker-doctor/cli@latest .` and confirm the score improved and no errors remain.");
+	return lines.join("\n");
+};
+
+//#endregion
+//#region src/agents/is-command-available.ts
+const WINDOWS_EXTENSIONS = [
+	".exe",
+	".cmd",
+	".bat"
+];
+const isCommandAvailable = (command) => {
+	const pathValue = process.env.PATH ?? "";
+	const extensions = process.platform === "win32" ? WINDOWS_EXTENSIONS : [""];
+	for (const dir of pathValue.split(node_path.default.delimiter)) {
+		if (dir === "") continue;
+		for (const extension of extensions) try {
+			node_fs.default.accessSync(node_path.default.join(dir, command + extension), node_fs.default.constants.X_OK);
+			return true;
+		} catch {}
+	}
+	return false;
+};
+
+//#endregion
+//#region src/agents/launchable-agents.ts
+const LAUNCHABLE_AGENT_IDS = [
+	"claude-code",
+	"codex",
+	"cursor"
+];
+const AGENT_BINARIES = {
+	"claude-code": "claude",
+	codex: "codex",
+	cursor: "cursor-agent"
+};
+const AGENT_AUTO_FLAGS = {
+	"claude-code": ["--dangerously-skip-permissions"],
+	codex: ["--yolo"],
+	cursor: ["--force"]
+};
+const detectLaunchableAgents = () => {
+	if (process.platform === "win32") return [];
+	return LAUNCHABLE_AGENT_IDS.filter((agentId) => isCommandAvailable(AGENT_BINARIES[agentId]));
+};
+
+//#endregion
+//#region src/agents/launch-agent.ts
+const launchAgent = (agentId, prompt) => new Promise((resolve) => {
+	const child = (0, node_child_process.spawn)(AGENT_BINARIES[agentId], [...AGENT_AUTO_FLAGS[agentId], prompt], { stdio: "inherit" });
+	child.once("error", () => {
+		resolve(false);
+	});
+	child.once("exit", () => {
+		resolve(true);
+	});
+});
+
+//#endregion
+//#region src/agents/skill-install.ts
+const moduleDir = __dirname;
+const getSkillSourceDirectory = () => {
+	const candidates = [node_path.default.resolve(moduleDir, "../skill/docker-doctor"), node_path.default.resolve(moduleDir, "../../../../skills/docker-doctor")];
+	for (const candidate of candidates) if (node_fs.default.existsSync(node_path.default.join(candidate, agent_install.SKILL_MANIFEST_FILE))) return candidate;
+	return null;
+};
+const installSkillForAgents = async (agents, projectRoot) => {
+	const source = getSkillSourceDirectory();
+	if (!source) return null;
+	try {
+		return await (0, agent_install.installSkillsFromSource)({
+			agents,
+			cwd: projectRoot,
+			mode: "copy",
+			source
+		});
+	} catch {
+		return null;
+	}
+};
+
+//#endregion
 //#region src/formatters/terminal.ts
 const printCodeFrame = (content, line, severityColor) => {
 	if (!content || !line) return;
@@ -23,23 +663,23 @@ const printCodeFrame = (content, line, severityColor) => {
 		const rawLine = lines[i - 1];
 		const isTarget = i === line;
 		const lineNumberStr = String(i).padStart(5, " ");
-		if (isTarget) console.log(`  ${severityColor(">")} ${chalk.default.bold(lineNumberStr)} │ ${chalk.default.white(rawLine)}`);
-		else console.log(`    ${chalk.default.dim(lineNumberStr)} │ ${chalk.default.dim(rawLine)}`);
+		if (isTarget) console.log(`  ${severityColor(">")} ${chalk.bold(lineNumberStr)} │ ${chalk.white(rawLine)}`);
+		else console.log(`    ${chalk.dim(lineNumberStr)} │ ${chalk.dim(rawLine)}`);
 	}
 	console.log();
 };
 const printDiscoveredFiles = (project) => {
 	console.log(`\nDiscovered Files:`);
-	console.log(`  Dockerfile(s): ${project.dockerfiles.length ? project.dockerfiles.map((f) => chalk.default.cyan(f)).join(", ") : chalk.default.dim("None")}`);
-	console.log(`  Compose file(s):  ${project.composeFiles.length ? project.composeFiles.map((f) => chalk.default.cyan(f)).join(", ") : chalk.default.dim("None")}`);
+	console.log(`  Dockerfile(s): ${project.dockerfiles.length ? project.dockerfiles.map((f) => chalk.cyan(f)).join(", ") : chalk.dim("None")}`);
+	console.log(`  Compose file(s):  ${project.composeFiles.length ? project.composeFiles.map((f) => chalk.cyan(f)).join(", ") : chalk.dim("None")}`);
 };
 const printDiagnostics = (diagnostics, verbose, fileContents, categoryIssueCounts) => {
 	if (diagnostics.length === 0) {
-		console.log(`\n${chalk.default.green.bold("✔ No issues found! Your Docker setup looks healthy.")}`);
+		console.log(`\n${chalk.green.bold("✔ No issues found! Your Docker setup looks healthy.")}`);
 		return;
 	}
 	if (!verbose) {
-		console.log(`\n  All ${chalk.default.bold(diagnostics.length)} issues\n`);
+		console.log(`\n  All ${chalk.bold(diagnostics.length)} issues\n`);
 		for (const cat of [
 			"Security",
 			"Performance",
@@ -49,16 +689,16 @@ const printDiagnostics = (diagnostics, verbose, fileContents, categoryIssueCount
 		]) {
 			const count = categoryIssueCounts[cat];
 			const issueLabel = count === 1 ? "1 issue" : `${count} issues`;
-			console.log(`  ${cat} › ${chalk.default.dim(issueLabel)}`);
+			console.log(`  ${cat} › ${chalk.dim(issueLabel)}`);
 		}
-		console.log(`\n  Run ${chalk.default.cyan("docker-doctor --verbose")} to list every error and warning`);
+		console.log(`\n  Run ${chalk.cyan("docker-doctor --verbose")} to list every error and warning`);
 		const ruleCounts = {};
 		for (const d of diagnostics) ruleCounts[d.rule] = (ruleCounts[d.rule] || 0) + 1;
 		const migrationRules = Object.entries(ruleCounts).filter(([_, count]) => count >= 5);
 		if (migrationRules.length > 0) {
 			console.log();
-			console.log(`  ${chalk.default.yellow("⚠ Migration-scale change: sample before you sweep")}`);
-			for (const [rule, count] of migrationRules) console.log(`    ${chalk.default.cyan(rule)} ×${count} across ${count} files`);
+			console.log(`  ${chalk.yellow("⚠ Migration-scale change: sample before you sweep")}`);
+			for (const [rule, count] of migrationRules) console.log(`    ${chalk.cyan(rule)} ×${count} across ${count} files`);
 			console.log(`    Fixing all of them at once is hard to review and prone to`);
 			console.log(`    subtle mistakes across the whole repo. Fix a representative`);
 			console.log(`    few first and confirm the recipe holds. Then get the code`);
@@ -67,30 +707,30 @@ const printDiagnostics = (diagnostics, verbose, fileContents, categoryIssueCount
 		}
 		return;
 	}
-	console.log(`\nFound ${chalk.default.bold(diagnostics.length)} issue(s):`);
+	console.log(`\nFound ${chalk.bold(diagnostics.length)} issue(s):`);
 	const filesGrouped = {};
 	for (const d of diagnostics) {
 		if (!filesGrouped[d.file]) filesGrouped[d.file] = [];
 		filesGrouped[d.file].push(d);
 	}
 	for (const [file, fileDiags] of Object.entries(filesGrouped)) {
-		console.log(`\n${chalk.default.underline.bold(file)}`);
+		console.log(`\n${chalk.underline.bold(file)}`);
 		for (const d of fileDiags) {
-			let sevColor = chalk.default.cyan;
+			let sevColor = chalk.cyan;
 			let prefix = "ℹ INFO";
 			if (d.severity === "error") {
-				sevColor = chalk.default.red.bold;
+				sevColor = chalk.red.bold;
 				prefix = "✖ ERROR";
 			} else if (d.severity === "warning") {
-				sevColor = chalk.default.yellow;
+				sevColor = chalk.yellow;
 				prefix = "⚠ WARN";
 			}
 			const lineInfo = d.line ? `:${d.line}` : "";
-			console.log(`  ${sevColor(prefix)} [${chalk.default.dim(d.rule)}]${lineInfo}`);
+			console.log(`  ${sevColor(prefix)} [${chalk.dim(d.rule)}]${lineInfo}`);
 			const content = fileContents[file];
 			printCodeFrame(content, d.line, sevColor);
-			console.log(`    ${chalk.default.white(d.message)}`);
-			console.log(`    ${chalk.default.dim("Help:")} ${d.help}`);
+			console.log(`    ${chalk.white(d.message)}`);
+			console.log(`    ${chalk.dim("Help:")} ${d.help}`);
 			console.log();
 		}
 	}
@@ -100,10 +740,10 @@ const getWhaleMascot = (score, border) => {
 	let spout = "        ";
 	if (score >= 75) {
 		eyes = "◠ ◠";
-		spout = chalk.default.cyan("  \":\"   ");
+		spout = chalk.cyan("  \":\"   ");
 	} else if (score >= 50) {
 		eyes = "• •";
-		spout = chalk.default.cyan("   .    ");
+		spout = chalk.cyan("   .    ");
 	}
 	return [
 		spout,
@@ -116,10 +756,10 @@ const easeOutCubic = (x) => 1 - (1 - x) ** 3;
 const printScoreBox = async (score, label, categoryIssueCounts, warningsCount, errorsCount) => {
 	const { isTTY } = process.stdout;
 	const shouldAnimate = isTTY && !process.env.CI && !process.env.NO_ANIMATION && process.env.TERM !== "dumb" && process.env.NODE_ENV !== "test";
-	let scoreColor = chalk.default.red.bold;
-	if (score >= 90) scoreColor = chalk.default.green.bold;
-	else if (score >= 75) scoreColor = chalk.default.yellow.bold;
-	else if (score >= 50) scoreColor = chalk.default.magenta.bold;
+	let scoreColor = chalk.red.bold;
+	if (score >= 90) scoreColor = chalk.green.bold;
+	else if (score >= 75) scoreColor = chalk.yellow.bold;
+	else if (score >= 50) scoreColor = chalk.magenta.bold;
 	const whaleLines = getWhaleMascot(score, scoreColor);
 	const shareUrl = `https://docker-doctor.vercel.app/share?s=${score}&w=${warningsCount}&e=${errorsCount}`;
 	if (shouldAnimate) {
@@ -132,10 +772,10 @@ const printScoreBox = async (score, label, categoryIssueCounts, warningsCount, e
 				const currentScore = Math.round(score * progress);
 				const filledBlocks = Math.round(currentScore / 2);
 				const emptyBlocks = 50 - filledBlocks;
-				const bar = scoreColor("█".repeat(filledBlocks)) + chalk.default.dim("░".repeat(emptyBlocks));
+				const bar = scoreColor("█".repeat(filledBlocks)) + chalk.dim("░".repeat(emptyBlocks));
 				if (frame > 0) process.stdout.write("\x1B[4A\r");
 				else console.log();
-				process.stdout.write(`  ${whaleLines[0]}  ${scoreColor(`${currentScore} / 100`)} ${scoreColor(label)}\n  ${whaleLines[1]}  ${bar}\n  ${whaleLines[2]}  ${chalk.default.dim("Docker Doctor (https://docker-doctor.vercel.app)")}\n  ${whaleLines[3]}\n`);
+				process.stdout.write(`  ${whaleLines[0]}  ${scoreColor(`${currentScore} / 100`)} ${scoreColor(label)}\n  ${whaleLines[1]}  ${bar}\n  ${whaleLines[2]}  ${chalk.dim("Docker Doctor (https://docker-doctor.vercel.app)")}\n  ${whaleLines[3]}\n`);
 				if (frame < frameCount) await (0, node_timers_promises.setTimeout)(frameDelay);
 			}
 		} finally {
@@ -144,24 +784,24 @@ const printScoreBox = async (score, label, categoryIssueCounts, warningsCount, e
 	} else {
 		const filledBlocks = Math.round(score / 2);
 		const emptyBlocks = 50 - filledBlocks;
-		const bar = scoreColor("█".repeat(filledBlocks)) + chalk.default.dim("░".repeat(emptyBlocks));
+		const bar = scoreColor("█".repeat(filledBlocks)) + chalk.dim("░".repeat(emptyBlocks));
 		console.log(`\n  ${whaleLines[0]}  ${scoreColor(`${score} / 100`)} ${scoreColor(label)}`);
 		console.log(`  ${whaleLines[1]}  ${bar}`);
-		console.log(`  ${whaleLines[2]}  ${chalk.default.dim("Docker Doctor (https://docker-doctor.vercel.app)")}`);
+		console.log(`  ${whaleLines[2]}  ${chalk.dim("Docker Doctor (https://docker-doctor.vercel.app)")}`);
 		console.log(`  ${whaleLines[3]}`);
 	}
-	console.log(`\n  ${chalk.default.dim("────────────────────────────────────────────────────────────")}\n`);
-	console.log(`  Share: ${chalk.default.cyan(shareUrl)}`);
+	console.log(`\n  ${chalk.dim("────────────────────────────────────────────────────────────")}\n`);
+	console.log(`  Share: ${chalk.cyan(shareUrl)}`);
 	console.log(`  Tell others how you did on socials\n`);
-	console.log(`  Docs: ${chalk.default.cyan("https://github.com/PunGrumpy/docker-doctor/docs")}`);
+	console.log(`  Docs: ${chalk.cyan("https://docker-doctor.vercel.app")}`);
 	console.log(`  Learn more about fixing issues, setting up CI/CD, and`);
 	console.log(`  configuring rules with a config file\n`);
-	console.log(`  GitHub: ${chalk.default.cyan("https://github.com/PunGrumpy/docker-doctor")}`);
+	console.log(`  GitHub: ${chalk.cyan("https://github.com/PunGrumpy/docker-doctor")}`);
 	console.log(`  Report issues and star the repository!`);
 };
 const formatTerminal = async (diagnostics, score, label, project, verbose = false, fileContents = {}) => {
 	if (verbose) {
-		console.log(`\n${chalk.default.bold("Docker Doctor Diagnostics")}`);
+		console.log(`\n${chalk.bold("Docker Doctor Diagnostics")}`);
 		console.log(`=================================`);
 		printDiscoveredFiles(project);
 	}
@@ -196,12 +836,12 @@ const askConfirm = (question, defaultYes = false) => {
 		process.stdout.write("\x1B[?25l");
 		const render = (firstTime = false) => {
 			if (!firstTime) process.stdout.write("\x1B[3A\r");
-			process.stdout.write(`\r\u001B[K  ${chalk.default.green("✔")} ${chalk.default.bold(question)}\n`);
-			const yesPrefix = value ? chalk.default.cyan("❯ ") : "  ";
-			const yesText = value ? chalk.default.cyan.bold("Yes") : chalk.default.dim("Yes");
+			process.stdout.write(`\r\u001B[K  ${chalk.green("✔")} ${chalk.bold(question)}\n`);
+			const yesPrefix = value ? chalk.cyan("❯ ") : "  ";
+			const yesText = value ? chalk.cyan.bold("Yes") : chalk.dim("Yes");
 			process.stdout.write(`\r\u001B[K${yesPrefix}${yesText}\n`);
-			const noPrefix = value ? "  " : chalk.default.cyan("❯ ");
-			const noText = value ? chalk.default.dim("No") : chalk.default.cyan.bold("No");
+			const noPrefix = value ? "  " : chalk.cyan("❯ ");
+			const noText = value ? chalk.dim("No") : chalk.cyan.bold("No");
 			process.stdout.write(`\r\u001B[K${noPrefix}${noText}\n`);
 		};
 		render(true);
@@ -224,7 +864,7 @@ const askConfirm = (question, defaultYes = false) => {
 			} else if (key.name === "return" || key.name === "enter" || str === "\r" || str === "\n") {
 				cleanup();
 				process.stdout.write("\x1B[3A\r\x1B[K");
-				process.stdout.write(`  ${chalk.default.green("✔")} ${chalk.default.bold(question)} › ${value ? chalk.default.cyan("Yes") : chalk.default.dim("No")}\n`);
+				process.stdout.write(`  ${chalk.green("✔")} ${chalk.bold(question)} › ${value ? chalk.cyan("Yes") : chalk.dim("No")}\n`);
 				process.stdout.write("\r\x1B[K\n");
 				process.stdout.write("\r\x1B[K\n");
 				process.stdout.write("\x1B[2A");
@@ -248,12 +888,12 @@ const askSelect = (question, options, defaultIndex = 0) => {
 		process.stdout.write("\x1B[?25l");
 		const render = (firstTime = false) => {
 			if (!firstTime) process.stdout.write(`\u001B[${options.length + 1}A\r`);
-			process.stdout.write(`\r\u001B[K  ${chalk.default.green("✔")} ${chalk.default.bold(question)}\n`);
+			process.stdout.write(`\r\u001B[K  ${chalk.green("✔")} ${chalk.bold(question)}\n`);
 			let i = 0;
 			for (const option of options) {
 				const isSelected = i === index;
-				const prefix = isSelected ? chalk.default.cyan("❯ ") : "  ";
-				const text = isSelected ? chalk.default.cyan.bold(option) : chalk.default.dim(option);
+				const prefix = isSelected ? chalk.cyan("❯ ") : "  ";
+				const text = isSelected ? chalk.cyan.bold(option) : chalk.dim(option);
 				process.stdout.write(`\r\u001B[K${prefix}${text}\n`);
 				i += 1;
 			}
@@ -275,7 +915,7 @@ const askSelect = (question, options, defaultIndex = 0) => {
 			} else if (key.name === "return" || key.name === "enter" || str === "\r" || str === "\n") {
 				cleanup();
 				process.stdout.write(`\u001B[${options.length + 1}A\r\u001B[K`);
-				process.stdout.write(`  ${chalk.default.green("✔")} ${chalk.default.bold(question)} › ${chalk.default.cyan(options[index])}\n`);
+				process.stdout.write(`  ${chalk.green("✔")} ${chalk.bold(question)} › ${chalk.cyan(options[index])}\n`);
 				for (const _ of options) process.stdout.write("\r\x1B[K\n");
 				process.stdout.write(`\u001B[${options.length}A`);
 				resolve(index);
@@ -288,7 +928,104 @@ const askSelect = (question, options, defaultIndex = 0) => {
 		process.stdin.on("keypress", handleKeypress);
 	});
 };
-const runInteractiveWizard = async () => {
+const askMultiSelect = (question, options) => {
+	if (!process.stdin.isTTY) return Promise.resolve(options.flatMap((option, i) => option.selected ? [i] : []));
+	return new Promise((resolve) => {
+		let index = 0;
+		const selected = options.map((option) => option.selected);
+		const lineCount = options.length + 2;
+		node_readline.default.emitKeypressEvents(process.stdin);
+		process.stdin.setRawMode(true);
+		process.stdin.resume();
+		process.stdout.write("\x1B[?25l");
+		const render = (firstTime = false) => {
+			if (!firstTime) process.stdout.write(`\u001B[${lineCount}A\r`);
+			process.stdout.write(`\r\u001B[K  ${chalk.green("✔")} ${chalk.bold(question)}\n`);
+			let i = 0;
+			for (const option of options) {
+				const isCursor = i === index;
+				const cursor = isCursor ? chalk.cyan("❯ ") : "  ";
+				const box = selected[i] ? chalk.cyan("[x]") : chalk.dim("[ ]");
+				let text = chalk.dim(option.label);
+				if (isCursor) text = chalk.cyan.bold(option.label);
+				else if (selected[i]) text = option.label;
+				process.stdout.write(`\r\u001B[K${cursor}${box} ${text}\n`);
+				i += 1;
+			}
+			process.stdout.write(`\r\u001B[K  ${chalk.dim("space to toggle · enter to confirm")}\n`);
+		};
+		render(true);
+		const handleKeypress = (str, key) => {
+			const cleanup = () => {
+				process.stdin.removeListener("keypress", handleKeypress);
+				if (process.stdin.isTTY) process.stdin.setRawMode(false);
+				process.stdin.pause();
+				process.stdout.write("\x1B[?25h");
+			};
+			if (key.name === "up" || key.name === "k") {
+				index = (index - 1 + options.length) % options.length;
+				render();
+			} else if (key.name === "down" || key.name === "j") {
+				index = (index + 1) % options.length;
+				render();
+			} else if (key.name === "space" || str === " ") {
+				selected[index] = !selected[index];
+				render();
+			} else if (key.name === "return" || key.name === "enter" || str === "\r" || str === "\n") {
+				cleanup();
+				const chosen = options.flatMap((option, i) => selected[i] ? [option.label] : []);
+				process.stdout.write(`\u001B[${lineCount}A\r\u001B[K`);
+				process.stdout.write(`  ${chalk.green("✔")} ${chalk.bold(question)} › ${chosen.length > 0 ? chalk.cyan(chosen.join(", ")) : chalk.dim("none")}\n`);
+				for (let i = 0; i < lineCount - 1; i += 1) process.stdout.write("\r\x1B[K\n");
+				process.stdout.write(`\u001B[${lineCount - 1}A`);
+				resolve(options.flatMap((_, i) => selected[i] ? [i] : []));
+			} else if (key.ctrl && key.name === "c") {
+				cleanup();
+				process.stdout.write("\n");
+				process.exit(130);
+			}
+		};
+		process.stdin.on("keypress", handleKeypress);
+	});
+};
+const printAgentPrompt = (payload) => {
+	console.log(`\n${chalk.dim("──── Agent prompt ────")}`);
+	console.log(payload);
+	console.log(chalk.dim("──────────────────────"));
+};
+const agentDisplayName = (agent) => agent === "universal" ? "Universal" : (0, agent_install.getSkillAgentConfig)(agent).displayName;
+const runAgentHandoff = async (context) => {
+	const launchable = detectLaunchableAgents();
+	const options = [
+		...launchable.map((agentId) => agentDisplayName(agentId)),
+		"Copy prompt to clipboard",
+		"Skip"
+	];
+	const skipIndex = options.length - 1;
+	const clipboardIndex = options.length - 2;
+	const choice = await askSelect("What would you like to do next?", options);
+	if (choice === skipIndex) return;
+	await writeDiagnosticsDirectory(context.diagnostics, context.report, context.rootDir);
+	await ensureGitignoreEntry(context.rootDir);
+	const payload = buildHandoffPayload({
+		diagnostics: context.diagnostics,
+		projectName: node_path.default.basename(context.rootDir)
+	});
+	if (choice === clipboardIndex) {
+		if (await copyToClipboard(payload)) console.log(`\n  ${chalk.green("✔")} Prompt copied — paste it into any agent or chat.`);
+		else printAgentPrompt(payload);
+		return;
+	}
+	const agentId = launchable[choice];
+	const installResult = await installSkillForAgents([agentId], context.rootDir);
+	if (installResult && installResult.installed.length > 0) console.log(`\n  ${chalk.green("✔")} Installed the docker-doctor skill for ${agentDisplayName(agentId)}`);
+	console.log(`\n  Handing off to ${agentDisplayName(agentId)}...\n`);
+	if (!await launchAgent(agentId, payload)) {
+		console.log(`  ${chalk.yellow("⚠")} Couldn't launch ${AGENT_BINARIES[agentId]}. Here's the prompt instead:`);
+		printAgentPrompt(payload);
+	}
+};
+const runInteractiveWizard = async (context) => {
 	try {
 		if (await askConfirm("Add Docker Doctor to GitHub Actions?")) {
 			const workflowDir = node_path.default.resolve(".github/workflows");
@@ -312,13 +1049,11 @@ jobs:
       - name: Run docker-doctor
         run: bunx docker-doctor .
 `, "utf-8");
-			console.log(`\n  ${chalk.default.green("✨")} Created ${chalk.default.cyan(".github/workflows/docker-doctor.yml")}!`);
+			console.log(`\n  ${chalk.green("✨")} Created ${chalk.cyan(".github/workflows/docker-doctor.yml")}!`);
 			console.log(`    Scan every pull request to prevent new Docker issues while you fix the backlog.`);
 		}
-		if (await askSelect("What would you like to do next?", ["View rules list", "Skip"]) === 0) {
-			console.log(`\n  ${chalk.default.bold("Available Rules:")}`);
-			for (const r of require_src.allRules) console.log(`    - ${chalk.default.cyan(r.key)}: ${r.message} (${chalk.default.dim(r.category)})`);
-		}
+		if (context.diagnostics.length === 0) return;
+		await runAgentHandoff(context);
 	} catch {}
 };
 const runRulesEngine = async (rootDir, project, rulesConfig, projectFilesList, fileContents, options, setStatus) => {
@@ -409,9 +1144,9 @@ program.argument("[dir]", "directory to scan", ".").option("-v, --verbose", "sho
 		};
 		if (process.stdout.isTTY && !isSilent) {
 			process.stdout.write("\x1B[?25l");
-			process.stdout.write(`${chalk.default.cyan(spinnerFrames[0])} ${statusText}`);
+			process.stdout.write(`${chalk.cyan(spinnerFrames[0])} ${statusText}`);
 			spinnerInterval = setInterval(() => {
-				process.stdout.write(`\r\u001B[K${chalk.default.cyan(spinnerFrames[frameIndex])} ${statusText}`);
+				process.stdout.write(`\r\u001B[K${chalk.cyan(spinnerFrames[frameIndex])} ${statusText}`);
 				frameIndex = (frameIndex + 1) % spinnerFrames.length;
 			}, 80);
 		}
@@ -437,21 +1172,26 @@ program.argument("[dir]", "directory to scan", ".").option("-v, --verbose", "sho
 				spinnerInterval = null;
 				process.stdout.write("\r\x1B[K\x1B[?25h");
 			}
-			if (process.stdout.isTTY && !isSilent) console.log(`${chalk.default.green("✔")} Scanned ${projectFilesList.length} files in ${duration}s [~${concurrency} workers]`);
+			if (process.stdout.isTTY && !isSilent) console.log(`${chalk.green("✔")} Scanned ${projectFilesList.length} files in ${duration}s [~${concurrency} workers]`);
 			if (options.score) {
 				console.log(score);
-				process.exit(score < 50 ? 1 : 0);
+				process.exitCode = score < 50 ? 1 : 0;
+				return;
 			} else if (options.json) {
 				const report = require_src.toJsonReport(filteredDiagnostics, score, label, project);
 				console.log(JSON.stringify(report, null, 2));
 				const hasErrors = filteredDiagnostics.some((d) => d.severity === "error");
-				process.exit(hasErrors ? 1 : 0);
-			} else {
-				await formatTerminal(filteredDiagnostics, score, label, project, options.verbose, fileContents);
-				const hasErrors = filteredDiagnostics.some((d) => d.severity === "error");
-				if (process.stdout.isTTY && process.stdin.isTTY) await runInteractiveWizard();
-				process.exit(hasErrors ? 1 : 0);
+				process.exitCode = hasErrors ? 1 : 0;
+				return;
 			}
+			await formatTerminal(filteredDiagnostics, score, label, project, options.verbose, fileContents);
+			const hasErrors = filteredDiagnostics.some((d) => d.severity === "error");
+			if (process.stdout.isTTY && process.stdin.isTTY) await runInteractiveWizard({
+				diagnostics: filteredDiagnostics,
+				report: require_src.toJsonReport(filteredDiagnostics, score, label, project),
+				rootDir
+			});
+			process.exitCode = hasErrors ? 1 : 0;
 		} finally {
 			if (spinnerInterval !== null) {
 				clearInterval(spinnerInterval);
@@ -464,6 +1204,55 @@ program.argument("[dir]", "directory to scan", ".").option("-v, --verbose", "sho
 		process.exit(1);
 	}
 });
+const CURATED_INSTALL_AGENTS = [
+	"claude-code",
+	"codex",
+	"cursor",
+	"opencode"
+];
+const resolveInstallAgents = async (requested) => {
+	if (requested && requested.length > 0) {
+		const invalid = requested.filter((agent) => !(0, agent_install.isSkillAgentType)(agent));
+		if (invalid.length > 0) {
+			console.error(`Unknown agent id(s): ${invalid.join(", ")}`);
+			console.error(`Valid ids: ${(0, agent_install.getSkillAgentTypes)().filter((agent) => agent !== "universal").join(", ")}`);
+			return null;
+		}
+		return requested.filter((agent) => (0, agent_install.isSkillAgentType)(agent));
+	}
+	if (!(process.stdin.isTTY && process.stdout.isTTY)) {
+		console.error("Non-interactive run: pass --agent <id...> (e.g. --agent claude-code cursor).");
+		return null;
+	}
+	const detected = (await (0, agent_install.detectInstalledSkillAgents)()).filter((agent) => agent !== "universal");
+	const choices = [.../* @__PURE__ */ new Set([...detected, ...CURATED_INSTALL_AGENTS])];
+	const detectedSet = new Set(detected);
+	return (await askMultiSelect("Which coding agents should get the docker-doctor skill?", choices.map((agent) => ({
+		label: agentDisplayName(agent),
+		selected: detectedSet.has(agent)
+	})))).map((i) => choices[i]);
+};
+program.command("install").description("install the Docker Doctor agent skill for your coding agents").option("-a, --agent <agents...>", "agent id(s) to install for (e.g. claude-code codex cursor)").action(async (options) => {
+	if (!getSkillSourceDirectory()) {
+		console.error("Bundled skill not found — this looks like a broken installation.");
+		process.exit(1);
+	}
+	const agents = await resolveInstallAgents(options.agent);
+	if (agents === null) process.exit(1);
+	if (agents.length === 0) {
+		console.log("Nothing selected — skipped.");
+		return;
+	}
+	const result = await installSkillForAgents(agents, process.cwd());
+	if (!result) {
+		console.error("Failed to install the skill.");
+		process.exit(1);
+	}
+	for (const installed of result.installed) console.log(`  ${chalk.green("✔")} ${agentDisplayName(installed.agent)} → ${installed.path}`);
+	for (const failed of result.failed) console.log(`  ${chalk.red("✖")} ${agentDisplayName(failed.agent)}: ${failed.error}`);
+	if (result.installed.length > 0) console.log(`\n  The agent can now run ${chalk.cyan("/docker-doctor")} to scan and triage this project.`);
+	process.exitCode = result.failed.length > 0 ? 1 : 0;
+});
 const rules = program.command("rules").description("manage and list configuration rules");
 rules.command("list").description("list all available rules").action(() => {
 	console.log("\nAvailable Rules:");