@sayknow-cli/coding-agent 0.3.0 → 0.3.2

package/src/cli/mcp-cli.ts

@@ -0,0 +1,272 @@
+/**
+ * Direct MCP server registration CLI helpers.
+ *
+ * This surface only writes explicit user-provided server definitions to SKC's
+ * own MCP config. It never imports or inherits live configs from other agents.
+ */
+import { getMCPConfigPath, getProjectDir } from "@sayknow-cli/utils";
+import { getMCPServer, readMCPConfigFile, removeMCPServer, upsertMCPServer } from "../runtime-mcp/config-writer";
+import type { MCPConfigFile, MCPServerConfig } from "../runtime-mcp/types";
+
+export type MCPAction = "add" | "list" | "remove";
+
+export interface MCPCommandArgs {
+	action: MCPAction;
+	name?: string;
+	commandArgs?: string[];
+	flags: {
+		project?: boolean;
+		force?: boolean;
+		json?: boolean;
+		type?: "stdio" | "http" | "sse";
+		command?: string;
+		url?: string;
+		arg?: string[];
+		env?: string[];
+		header?: string[];
+		cwd?: string;
+		timeout?: number;
+	};
+	cwd?: string;
+}
+
+export class MCPArgsError extends Error {}
+
+interface ScopedPath {
+	scope: "user" | "project";
+	path: string;
+}
+
+interface RedactedServerEntry {
+	name: string;
+	config: MCPServerConfig;
+}
+
+const REDACTED = "<redacted>";
+const SENSITIVE_KEY_PATTERN =
+	/(?:token|secret|key|credential|password|passwd|pwd|authorization|auth|bearer|cookie|session)/i;
+
+function resolvePath(args: MCPCommandArgs): ScopedPath {
+	const scope = args.flags.project ? "project" : "user";
+	return { scope, path: getMCPConfigPath(scope, args.cwd ?? getProjectDir()) };
+}
+
+function parsePairs(values: string[] | undefined, label: string): Record<string, string> | undefined {
+	if (!values || values.length === 0) return undefined;
+	const parsed: Record<string, string> = {};
+	for (const value of values) {
+		const index = value.indexOf("=");
+		if (index <= 0) {
+			throw new MCPArgsError(`Invalid ${label}. Use KEY=VALUE.`);
+		}
+		const key = value.slice(0, index).trim();
+		if (!key) {
+			throw new MCPArgsError(`Invalid ${label}. Key cannot be empty.`);
+		}
+		parsed[key] = value.slice(index + 1);
+	}
+	return parsed;
+}
+
+function buildServerConfig(args: MCPCommandArgs): MCPServerConfig {
+	const type = args.flags.type ?? (args.flags.url ? "http" : "stdio");
+	const timeout = args.flags.timeout;
+	const shared = timeout === undefined ? {} : { timeout };
+
+	if (type === "stdio") {
+		const command = args.flags.command ?? args.commandArgs?.[0];
+		if (!command) {
+			throw new MCPArgsError("`skc mcp add` requires --command <cmd> or a positional command for stdio servers.");
+		}
+		const config: MCPServerConfig = {
+			...shared,
+			type: "stdio",
+			command,
+		};
+		const positionalArgs = args.flags.command ? [] : (args.commandArgs ?? []).slice(1);
+		const serverArgs = [...positionalArgs, ...(args.flags.arg ?? [])];
+		if (serverArgs.length > 0) config.args = serverArgs;
+		const env = parsePairs(args.flags.env, "env");
+		if (env) config.env = env;
+		if (args.flags.cwd) config.cwd = args.flags.cwd;
+		return config;
+	}
+
+	const url = args.flags.url ?? args.commandArgs?.[0];
+	if (!url) {
+		throw new MCPArgsError(`\`skc mcp add --type ${type}\` requires --url <url> or a positional URL.`);
+	}
+	const headers = parsePairs(args.flags.header, "header");
+	if (type === "http") {
+		const config: MCPServerConfig = {
+			...shared,
+			type,
+			url,
+		};
+		if (headers) config.headers = headers;
+		return config;
+	}
+	const config: MCPServerConfig = {
+		...shared,
+		type,
+		url,
+	};
+	if (headers) config.headers = headers;
+	return config;
+}
+
+function redactRecord(
+	record: Record<string, string> | undefined,
+	redactAllValues: boolean,
+): Record<string, string> | undefined {
+	if (!record) return undefined;
+	return Object.fromEntries(
+		Object.entries(record).map(([key, value]) => [
+			key,
+			redactAllValues || SENSITIVE_KEY_PATTERN.test(key) ? REDACTED : value,
+		]),
+	);
+}
+
+export function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig {
+	const redacted = { ...config } as MCPServerConfig;
+	if ("env" in redacted) {
+		const env = redactRecord(redacted.env, true);
+		if (env) redacted.env = env;
+	}
+	if ("headers" in redacted) {
+		const headers = redactRecord(redacted.headers, true);
+		if (headers) redacted.headers = headers;
+	}
+	if (redacted.auth) {
+		redacted.auth = {
+			type: redacted.auth.type,
+			credentialId: redacted.auth.credentialId ? REDACTED : undefined,
+			tokenUrl: redacted.auth.tokenUrl,
+			clientId: redacted.auth.clientId ? REDACTED : undefined,
+			clientSecret: redacted.auth.clientSecret ? REDACTED : undefined,
+		};
+	}
+	if (redacted.oauth) {
+		redacted.oauth = {
+			clientId: redacted.oauth.clientId ? REDACTED : undefined,
+			clientSecret: redacted.oauth.clientSecret ? REDACTED : undefined,
+			redirectUri: redacted.oauth.redirectUri,
+			callbackPort: redacted.oauth.callbackPort,
+			callbackPath: redacted.oauth.callbackPath,
+		};
+	}
+	return redacted;
+}
+
+function collectEntries(config: MCPConfigFile): RedactedServerEntry[] {
+	return Object.entries(config.mcpServers ?? {})
+		.sort(([a], [b]) => a.localeCompare(b))
+		.map(([name, serverConfig]) => ({ name, config: redactMCPServerConfig(serverConfig) }));
+}
+
+function writeJson(value: unknown): void {
+	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+function renderServerLine(entry: RedactedServerEntry): string {
+	const config = entry.config;
+	if (config.type === "http" || config.type === "sse") {
+		return `${entry.name}\t${config.type}\t${config.url}`;
+	}
+	const args = config.args && config.args.length > 0 ? ` ${config.args.join(" ")}` : "";
+	return `${entry.name}\tstdio\t${config.command}${args}`;
+}
+
+function renderDetails(entry: RedactedServerEntry): string {
+	return `${renderServerLine(entry)}\n${JSON.stringify(entry.config, null, 2)}`;
+}
+
+async function runAdd(args: MCPCommandArgs, scoped: ScopedPath): Promise<void> {
+	if (!args.name) throw new MCPArgsError("`skc mcp add` requires a server name.");
+	const config = buildServerConfig(args);
+	const result = await upsertMCPServer(scoped.path, args.name, config, { force: args.flags.force });
+	const redacted = redactMCPServerConfig(config);
+	if (args.flags.json) {
+		writeJson({
+			action: "add",
+			status: result.status,
+			name: args.name,
+			scope: scoped.scope,
+			path: scoped.path,
+			config: redacted,
+		});
+		return;
+	}
+	if (result.status === "skipped") {
+		process.stdout.write(
+			`MCP server "${args.name}" already exists in ${scoped.scope} config. Pass --force to overwrite.\n`,
+		);
+		return;
+	}
+	process.stdout.write(`MCP server "${args.name}" ${result.status} in ${scoped.scope} config: ${scoped.path}\n`);
+}
+
+async function runList(args: MCPCommandArgs, scoped: ScopedPath): Promise<void> {
+	const config = await readMCPConfigFile(scoped.path);
+	const entries = collectEntries(config);
+	if (args.flags.json) {
+		writeJson({ action: "list", scope: scoped.scope, path: scoped.path, servers: entries });
+		return;
+	}
+	if (entries.length === 0) {
+		process.stdout.write(`No MCP servers registered in ${scoped.scope} config: ${scoped.path}\n`);
+		return;
+	}
+	process.stdout.write(`MCP servers in ${scoped.scope} config: ${scoped.path}\n`);
+	for (const entry of entries) {
+		process.stdout.write(`${renderDetails(entry)}\n`);
+	}
+}
+
+async function runRemove(args: MCPCommandArgs, scoped: ScopedPath): Promise<void> {
+	if (!args.name) throw new MCPArgsError("`skc mcp remove` requires a server name.");
+	const existing = await getMCPServer(scoped.path, args.name);
+	if (!existing) {
+		throw new MCPArgsError(`MCP server "${args.name}" not found in ${scoped.scope} config.`);
+	}
+	await removeMCPServer(scoped.path, args.name);
+	const entry = { name: args.name, config: redactMCPServerConfig(existing) };
+	if (args.flags.json) {
+		writeJson({
+			action: "remove",
+			status: "removed",
+			name: args.name,
+			scope: scoped.scope,
+			path: scoped.path,
+			removed: entry,
+		});
+		return;
+	}
+	process.stdout.write(`Removed MCP server "${args.name}" from ${scoped.scope} config: ${scoped.path}\n`);
+	process.stdout.write(`${renderDetails(entry)}\n`);
+}
+
+export async function runMCPCommand(args: MCPCommandArgs): Promise<void> {
+	const scoped = resolvePath(args);
+	try {
+		switch (args.action) {
+			case "add":
+				await runAdd(args, scoped);
+				return;
+			case "list":
+				await runList(args, scoped);
+				return;
+			case "remove":
+				await runRemove(args, scoped);
+				return;
+		}
+	} catch (error) {
+		if (error instanceof MCPArgsError) {
+			process.stderr.write(`${error.message}\n`);
+			process.exitCode = 2;
+			return;
+		}
+		throw error;
+	}
+}

package/src/cli/notify-cli.ts

@@ -29,6 +29,8 @@ export interface NotifyCommandDeps {
 	pollIntervalMs?: number;
 	setupChatId?: string;
 	setupRedact?: boolean;
+	setupInteractive?: boolean;
+	threadedModePrompt?: (message: string) => Promise<string>;
 }
 
 interface TelegramApiResponse<T> {
@@ -47,6 +49,18 @@ interface TelegramUpdate {
 	};
 }
 
+interface TelegramUser {
+	id: number;
+	is_bot?: boolean;
+	first_name?: string;
+	username?: string;
+	has_topics_enabled?: boolean;
+	allows_users_to_create_topics?: boolean;
+}
+
+type ThreadedModeState = "enabled" | "disabled" | "unknown";
+type ThreadedModeFinalLabel = "verified" | "unverified" | "unknown";
+
 const DEFAULT_API_BASE = "https://api.telegram.org";
 const DEFAULT_POLL_TIMEOUT_MS = 60_000;
 const DEFAULT_POLL_INTERVAL_MS = 1_000;
@@ -120,7 +134,11 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 		throw new Error("Telegram bot token is required.");
 	}
 
-	await callTelegram(fetchImpl, apiBase, token, "getMe", {});
+	const user = await getMe(fetchImpl, apiBase, token);
+	const threadedState = await verifyThreadedMode(fetchImpl, apiBase, token, user, {
+		interactive: resolveSetupInteractive(deps),
+		prompt: deps.threadedModePrompt ?? promptForThreadedMode,
+	});
 	process.stdout.write(
 		"Token validated. Message your bot now from the private Telegram chat to pair notifications.\n",
 	);
@@ -145,7 +163,9 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 	if (deps.setupRedact) settings.set("notifications.redact", true);
 	await settings.flush();
 
-	process.stdout.write(`Notifications enabled. botToken=${maskToken(token)} chatId=${chatId}\n`);
+	process.stdout.write(
+		`Notifications enabled. botToken=${maskToken(token)} chatId=${chatId} threaded=${threadedLabel(threadedState)}\n`,
+	);
 }
 
 async function promptForToken(): Promise<string> {
@@ -160,14 +180,135 @@ async function promptForToken(): Promise<string> {
 	}
 }
 
+const THREADED_ENABLED_SUCCESS =
+	"Telegram Threaded Mode capability verified for this bot. SKC will request a private-chat topic per session; if Telegram ever refuses topic creation, notifications fall back to this flat chat with a one-time nudge.\n";
+
+const THREADED_MISSING_WARNING =
+	"Warning: Telegram getMe did not include has_topics_enabled, so SKC cannot verify private-chat Threaded Mode capability for this bot. Setup will continue; update Telegram/Bot API support or re-run setup if per-session topics fail.\n";
+
+const THREADED_NONINTERACTIVE_WARNING =
+	"Warning: Telegram Threaded Mode capability is OFF for this bot. Setup will be saved because this run is non-interactive, but per-session Telegram delivery may fail closed until the bot owner enables Threaded Mode in @BotFather. SKC cannot enable it through the Bot API.\n";
+
+const THREADED_DISABLED_GUIDANCE =
+	"Telegram Threaded Mode is OFF for this bot. SKC needs Telegram private-chat topics so each session can use its own thread.\n" +
+	"SKC cannot enable this through the Bot API. Open @BotFather, select this bot, enable Threaded Mode / forum topics for private chats, then return here.\n" +
+	"Telegram may require an additional Stars purchase fee for private-chat topics.\n";
+
+const THREADED_DISABLED_PROMPT =
+	"Press Enter after enabling Threaded Mode, or type skip to finish setup with a warning: ";
+
+const THREADED_STILL_OFF = "Telegram still reports Threaded Mode OFF for this bot.\n";
+
+const THREADED_RETRY_PROMPT = "Press Enter to check again, or type skip to finish setup with a warning: ";
+
+const THREADED_SKIP_WARNING =
+	"Warning: continuing without verified Telegram Threaded Mode capability. Setup will be saved, but per-session Telegram delivery may fail closed until Threaded Mode is enabled in BotFather.\n";
+
+const THREADED_INVALID_INPUT = "Type Enter to retry or skip to continue with a warning.\n";
+
+const THREADED_RETRY_INPUTS = new Set(["", "y", "yes", "r", "retry"]);
+const THREADED_SKIP_INPUTS = new Set(["s", "skip", "n", "no"]);
+
+function isTelegramUser(value: unknown): value is TelegramUser {
+	return Boolean(value) && typeof value === "object" && typeof (value as { id?: unknown }).id === "number";
+}
+
+async function getMe(fetchImpl: typeof fetch, apiBase: string, token: string): Promise<TelegramUser> {
+	const user = await callTelegram<unknown>(fetchImpl, apiBase, token, "getMe", {});
+	if (!isTelegramUser(user)) {
+		throw new Error("Telegram getMe returned invalid Telegram response: missing valid User result.");
+	}
+	return user;
+}
+
+function threadedModeState(user: TelegramUser): ThreadedModeState {
+	if (user.has_topics_enabled === true) return "enabled";
+	if (user.has_topics_enabled === false) return "disabled";
+	return "unknown";
+}
+
+function threadedLabel(state: ThreadedModeState): ThreadedModeFinalLabel {
+	if (state === "enabled") return "verified";
+	if (state === "disabled") return "unverified";
+	return "unknown";
+}
+
+function resolveSetupInteractive(deps: NotifyCommandDeps): boolean {
+	if (deps.setupInteractive !== undefined) return deps.setupInteractive;
+	return Boolean(process.stdin.isTTY) && !deps.setupChatId?.trim();
+}
+
+async function promptForThreadedMode(message: string): Promise<string> {
+	if (!process.stdin.isTTY) return "skip";
+	const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+	try {
+		return (await rl.question(message)).trim();
+	} finally {
+		rl.close();
+	}
+}
+
+async function verifyThreadedMode(
+	fetchImpl: typeof fetch,
+	apiBase: string,
+	token: string,
+	initialUser: TelegramUser,
+	opts: { interactive: boolean; prompt: (message: string) => Promise<string> },
+): Promise<ThreadedModeState> {
+	const classify = (user: TelegramUser): ThreadedModeState | undefined => {
+		const state = threadedModeState(user);
+		if (state === "enabled") {
+			process.stdout.write(THREADED_ENABLED_SUCCESS);
+			return "enabled";
+		}
+		if (state === "unknown") {
+			process.stdout.write(THREADED_MISSING_WARNING);
+			return "unknown";
+		}
+		return undefined;
+	};
+
+	const initial = classify(initialUser);
+	if (initial) return initial;
+
+	if (!opts.interactive) {
+		process.stdout.write(THREADED_NONINTERACTIVE_WARNING);
+		return "disabled";
+	}
+
+	process.stdout.write(THREADED_DISABLED_GUIDANCE);
+	let firstPrompt = true;
+	for (;;) {
+		const answer = (await opts.prompt(firstPrompt ? THREADED_DISABLED_PROMPT : THREADED_RETRY_PROMPT))
+			.trim()
+			.toLowerCase();
+		firstPrompt = false;
+		if (THREADED_SKIP_INPUTS.has(answer)) {
+			process.stdout.write(THREADED_SKIP_WARNING);
+			return "disabled";
+		}
+		if (!THREADED_RETRY_INPUTS.has(answer)) {
+			process.stdout.write(THREADED_INVALID_INPUT);
+			continue;
+		}
+		const resolved = classify(await getMe(fetchImpl, apiBase, token));
+		if (resolved) return resolved;
+		process.stdout.write(THREADED_STILL_OFF);
+	}
+}
+
 async function runStatus(deps: NotifyCommandDeps): Promise<void> {
 	const settings = await getSettings(deps);
 	const cfg = getNotificationConfig(settings);
 	process.stdout.write(
 		`${chalk.bold("Notifications")}\n` +
 			`  enabled: ${cfg.enabled}\n` +
-			`  botToken: ${maskToken(cfg.botToken)}\n` +
-			`  chatId: ${cfg.chatId ?? "(unset)"}\n` +
+			`  telegram.botToken: ${maskToken(cfg.botToken)}\n` +
+			`  telegram.chatId: ${cfg.chatId ?? "(unset)"}\n` +
+			`  discord.botToken: ${maskToken(cfg.discord.botToken)}\n` +
+			`  discord.channelId: ${cfg.discord.channelId ?? "(unset)"}\n` +
+			`  slack.botToken: ${maskToken(cfg.slack.botToken)}\n` +
+			`  slack.channelId: ${cfg.slack.channelId ?? "(unset)"}\n` +
 			`  redact: ${cfg.redact}\n`,
 	);
 }
@@ -263,12 +404,18 @@ ${chalk.bold("Usage:")}
   ${APP_NAME} notify status
 
 ${chalk.bold("Subcommands:")}
-  setup     Pair a Telegram bot token with a private chat
+  setup     Pair a Telegram bot token with a private chat and verify Threaded Mode capability
   status    Show notification configuration without secrets
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} notify setup
   ${APP_NAME} notify setup --token <botToken> --chat-id <chatId> [--redact]
   ${APP_NAME} notify status
+
+${chalk.bold("Threaded Mode:")}
+  SKC uses Telegram private-chat topics for per-session threads. Setup verifies the bot
+  capability via getMe.has_topics_enabled. If it is off, enable Threaded Mode in @BotFather;
+  bots cannot toggle it through the Bot API. If Telegram refuses topic creation at runtime,
+  SKC delivers flat to the paired private chat and nudges you to enable Threaded Mode.
 `);
 }

package/src/cli/plugin-cli.ts

@@ -16,6 +16,7 @@ import {
 	getPluginsCacheDir,
 	MarketplaceManager,
 } from "../extensibility/plugins/marketplace/index.js";
+import { installSkcPluginBundle, isSkcPluginBundleSource, readRegistry } from "../extensibility/skc-plugins";
 import { type ScanReport, scanPluginDir } from "../extensibility/plugins/security-scanner";
 import { theme } from "../modes/theme/theme";
 
@@ -50,6 +51,8 @@ export interface PluginCommandArgs {
 		disable?: string;
 		set?: string;
 		scope?: "user" | "project";
+		user?: boolean;
+		project?: boolean;
 	};
 }
 
@@ -111,6 +114,10 @@ export function parsePluginArgs(args: string[]): PluginCommandArgs | undefined {
 			result.flags.dryRun = true;
 		} else if (arg === "-l" || arg === "--local") {
 			result.flags.local = true;
+		} else if (arg === "--user") {
+			result.flags.user = true;
+		} else if (arg === "--project") {
+			result.flags.project = true;
 		} else if (arg === "--enable" && i + 1 < args.length) {
 			result.flags.enable = args[++i];
 		} else if (arg === "--disable" && i + 1 < args.length) {
@@ -366,7 +373,14 @@ function printSecurityAdvisory(report: ScanReport): void {
 async function handleInstall(
 	manager: PluginManager,
 	packages: string[],
-	flags: { json?: boolean; force?: boolean; dryRun?: boolean; scope?: "user" | "project" },
+	flags: {
+		json?: boolean;
+		force?: boolean;
+		dryRun?: boolean;
+		scope?: "user" | "project";
+		user?: boolean;
+		project?: boolean;
+	},
 ): Promise<void> {
 	if (packages.length === 0) {
 		console.error(chalk.red(`Usage: ${APP_NAME} plugin install <package[@version]>[features] ...`));
@@ -381,6 +395,32 @@ async function handleInstall(
 	const knownMarketplaces = new Set((await mktMgr.listMarketplaces()).map(m => m.name));
 
 	for (const spec of packages) {
+		// SKC plugin bundle classifier: a source containing sayknow-plugin.json (or a
+		// git/tarball source) routes to the bundle installer BEFORE marketplace/npm.
+		if (await isSkcPluginBundleSource(spec)) {
+			if (flags.user === flags.project) {
+				console.error(
+					chalk.red(`SKC plugin bundle install requires exactly one of --user or --project for "${spec}".`),
+				);
+				process.exit(1);
+			}
+			const scope: "user" | "project" = flags.user ? "user" : "project";
+			try {
+				const res = await installSkcPluginBundle(spec, { scope, cwd: process.cwd(), force: flags.force });
+				if (flags.json) {
+					console.log(JSON.stringify({ name: res.entry.name, status: res.status, scope }, null, 2));
+				} else {
+					console.log(
+						chalk.green(`${theme.status.success} ${res.status} SKC plugin ${res.entry.name} (${scope})`),
+					);
+				}
+			} catch (err) {
+				console.error(chalk.red(`${theme.status.error} Failed to install SKC plugin ${spec}: ${err}`));
+				process.exit(1);
+			}
+			continue;
+		}
+
 		const target = classifyInstallTarget(spec, knownMarketplaces);
 
 		if (target.type === "marketplace") {
@@ -519,13 +559,16 @@ async function handleList(manager: PluginManager, flags: { json?: boolean }): Pr
 	const npmPlugins = await manager.list();
 	const mktMgr = await makeMarketplaceManager();
 	const mktPlugins = await mktMgr.listInstalledPlugins();
+	const cwd = getProjectDir();
+	const [skcUser, skcProject] = await Promise.all([readRegistry("user", cwd), readRegistry("project", cwd)]);
+	const skcBundles = [...skcUser.plugins, ...skcProject.plugins];
 
 	if (flags.json) {
-		console.log(JSON.stringify({ npm: npmPlugins, marketplace: mktPlugins }, null, 2));
+		console.log(JSON.stringify({ npm: npmPlugins, marketplace: mktPlugins, skc: skcBundles }, null, 2));
 		return;
 	}
 
-	if (npmPlugins.length === 0 && mktPlugins.length === 0) {
+	if (npmPlugins.length === 0 && mktPlugins.length === 0 && skcBundles.length === 0) {
 		console.log(chalk.dim("No plugins installed"));
 		console.log(chalk.dim(`\nInstall plugins with: ${APP_NAME} plugin install <package>`));
 		return;
@@ -567,6 +610,26 @@ async function handleList(manager: PluginManager, flags: { json?: boolean }): Pr
 			console.log(`  ${plugin.id} (${version})${scopeLabel}${shadowLabel}`);
 		}
 	}
+
+	if (skcBundles.length > 0) {
+		if (npmPlugins.length > 0 || mktPlugins.length > 0) console.log();
+		console.log(chalk.bold("SKC Plugin Bundles:\n"));
+		for (const plugin of skcBundles) {
+			const status = plugin.enabled ? chalk.green(theme.status.enabled) : chalk.dim(theme.status.disabled);
+			const scopeLabel = chalk.dim(` (${plugin.scope})`);
+			const disabledCount = plugin.disabledSurfaceIds.length;
+			const quarantineCount = plugin.quarantine?.length ?? 0;
+			const detail = [
+				disabledCount > 0 ? `${disabledCount} disabled` : null,
+				quarantineCount > 0 ? `${quarantineCount} quarantined` : null,
+			]
+				.filter((v): v is string => Boolean(v))
+				.join(", ");
+			console.log(
+				`${status} ${plugin.name}@${plugin.version}${scopeLabel}${detail ? chalk.dim(` — ${detail}`) : ""}`,
+			);
+		}
+	}
 }
 
 async function handleLink(manager: PluginManager, paths: string[], flags: { json?: boolean }): Promise<void> {