@iowarp/clio-coder 0.4.6 → 0.4.7

package/src/cli/agents.ts

@@ -9,7 +9,7 @@ import { printError } from "./shared.js";
 
 const HELP = `clio-coder agents [--json] [--all]
 
-List user-facing agent specs from built-in, extension, user, and project recipes.
+List user-facing agent specs from built-in, plugin, user, and project recipes.
 
 Flags:
   --json   emit specs as JSON instead of the formatted table

package/src/cli/config-inspect.ts

@@ -52,7 +52,7 @@ export type CustomizationCategory =
 	| "safety"
 	| "memory";
 
-/** `reload` means an explicit `/resources extensions reload` (or a restart) publishes the change. */
+/** `reload` means an explicit `/extensions reload` (or a restart) publishes the change. */
 export type ReloadClass = "hot" | "next-turn" | "reload" | "restart" | "n/a";
 
 export interface CustomizationEntry {

package/src/cli/configure.ts

@@ -1372,7 +1372,7 @@ const SECTIONS: ReadonlyArray<SectionSpec> = [
 				["Chat thinking", settings.chat.thinkingLevel],
 				["Fleet thinking", settings.fleet.default.thinkingLevel],
 				["Favorites", listOr(settings.chat.modelPicker.favorites)],
-				["Cycle set (Alt+J/K)", listOr(settings.chat.modelPicker.cycleSet)],
+				["Model cycle set", listOr(settings.chat.modelPicker.cycleSet)],
 			];
 		},
 		actions: [
@@ -1437,7 +1437,7 @@ const SECTIONS: ReadonlyArray<SectionSpec> = [
 			},
 			{
 				label: "Cycle set",
-				hint: "comma-separated, Alt+J/K walks it",
+				hint: "comma-separated models for the scoped cycle actions",
 				run: async (io) => {
 					await askList(io, "Cycle set", readSettings().chat.modelPicker.cycleSet, (values) => {
 						updateSettings((draft) => {

package/src/cli/eval.ts

@@ -18,11 +18,15 @@ import { EvalSuiteFileError, loadEvalSuiteFile, loadV1TaskFileAsSuite } from "..
 import { resolveSuiteForRun } from "../domains/eval/suites/resolve.js";
 import { runEvalSuiteV2 } from "../domains/eval/suites/run.js";
 import { EvalTaskFileError } from "../domains/eval/task-file.js";
+import { resolveLibraryEval } from "../domains/resources/library-evals.js";
 import { printError } from "./shared.js";
 
 const HELP = `clio-coder eval <command>
 
 Commands:
+  clio-coder eval skill <name|path> [--scenario <id>] [--json]
+  clio-coder eval validate --package <path|kind:name> [--eval <name>] [--user|--project]
+  clio-coder eval run --package <path|kind:name> [--eval <name>] [--user|--project] [--out <path>]
   clio-coder eval validate --suite <suite.yaml>
 	  clio-coder eval run --suite <suite.yaml> [--trials <n>] [--target <id>] [--model <id>] [--out <path>] [--clio-coder-entry <path>]
 	  clio-coder eval run --task-file <tasks.yaml> [--repeat <n>] [--out <path>] [--clio-coder-entry <path>]
@@ -60,6 +64,9 @@ interface ParsedEvalArgs {
 	baseline?: string;
 	thresholds?: string;
 	help: boolean;
+	package?: string;
+	packageEval?: string;
+	packageScope?: "user" | "project";
 }
 
 function parseEvalArgs(args: ReadonlyArray<string>): ParsedEvalArgs {
@@ -84,6 +91,21 @@ function parseEvalArgs(args: ReadonlyArray<string>): ParsedEvalArgs {
 			}
 			throw new Error(`unknown eval command: ${arg}`);
 		}
+		if (parsed.command === "validate" || parsed.command === "run") {
+			if (arg === "--package" || arg === "--eval") {
+				const value = requiredValue(args, index++, arg);
+				if (arg === "--package") parsed.package = value;
+				else parsed.packageEval = value;
+				continue;
+			}
+			if (arg === "--user" || arg === "--project") {
+				const scope = arg === "--user" ? "user" : "project";
+				if (parsed.packageScope && parsed.packageScope !== scope)
+					throw new Error("--user and --project are mutually exclusive");
+				parsed.packageScope = scope;
+				continue;
+			}
+		}
 		if (parsed.command === "validate") {
 			if (arg === "--suite") {
 				parsed.suite = requiredValue(args, index, "--suite");
@@ -193,9 +215,12 @@ function parseEvalArgs(args: ReadonlyArray<string>): ParsedEvalArgs {
 	}
 	if (parsed.help) return parsed;
 	if (parsed.command === undefined) throw new Error("eval requires a command");
-	if (parsed.command === "validate" && parsed.suite === undefined) throw new Error("validate requires --suite <path>");
-	if (parsed.command === "run" && (parsed.suite === undefined) === (parsed.taskFile === undefined)) {
-		throw new Error("run requires exactly one of --suite or --task-file");
+	if (!parsed.package && (parsed.packageEval || parsed.packageScope))
+		throw new Error("--eval and scope flags require --package");
+	if (parsed.command === "validate" && [parsed.suite, parsed.package].filter(Boolean).length !== 1)
+		throw new Error("validate requires exactly one of --suite or --package");
+	if (parsed.command === "run" && [parsed.suite, parsed.taskFile, parsed.package].filter(Boolean).length !== 1) {
+		throw new Error("run requires exactly one of --suite, --task-file, or --package");
 	}
 	if (parsed.command === "report" && (parsed.evalId === undefined) === (parsed.artifact === undefined)) {
 		throw new Error("report requires exactly one of an eval id or --artifact <path>");
@@ -210,6 +235,7 @@ function parseEvalArgs(args: ReadonlyArray<string>): ParsedEvalArgs {
 }
 
 export async function runEvalCommand(args: ReadonlyArray<string>): Promise<number> {
+	if (args[0] === "skill") return (await import("./skills-eval.js")).runSkillEvalCli(args.slice(1));
 	// Routed before the shared parser so the fixed read stays exactly fixed: no
 	// eval flag can reach it, and no flag it does not name can be spent on it.
 	if (args[0] === "inventory") {
@@ -239,7 +265,10 @@ export async function runEvalCommand(args: ReadonlyArray<string>): Promise<numbe
 
 async function runEvalValidate(parsed: ParsedEvalArgs): Promise<number> {
 	try {
-		const loaded = await loadEvalSuiteFile(parsed.suite ?? "");
+		const declared = parsed.package
+			? resolveLibraryEval(parsed.package, parsed.packageEval, parsed.packageScope ? { scope: parsed.packageScope } : {})
+			: undefined;
+		const loaded = await loadEvalSuiteFile(declared?.path ?? parsed.suite ?? "");
 		process.stdout.write(`valid suite: ${loaded.suite.suite.id}\n`);
 		return 0;
 	} catch (error) {
@@ -249,10 +278,15 @@ async function runEvalValidate(parsed: ParsedEvalArgs): Promise<number> {
 
 async function runEvalRun(parsed: ParsedEvalArgs): Promise<number> {
 	try {
+		const declared = parsed.package
+			? resolveLibraryEval(parsed.package, parsed.packageEval, parsed.packageScope ? { scope: parsed.packageScope } : {})
+			: undefined;
+		const suitePath = declared?.path ?? parsed.suite;
 		const loaded =
-			parsed.suite !== undefined
-				? await loadEvalSuiteFile(parsed.suite)
+			suitePath !== undefined
+				? await loadEvalSuiteFile(suitePath)
 				: await loadV1TaskFileAsSuite(parsed.taskFile ?? "", parsed.trials ?? parsed.repeat);
+		if (declared) loaded.suite.suite.provenance = { ...loaded.suite.suite.provenance, library: declared.provenance };
 		const resolveOptions: { target?: string; model?: string } = {};
 		if (parsed.target !== undefined) resolveOptions.target = parsed.target;
 		if (parsed.model !== undefined) resolveOptions.model = parsed.model;

package/src/cli/extensions.ts

@@ -10,6 +10,7 @@ import {
 	listInstalledExtensions,
 	removeExtension,
 } from "../domains/extensions/index.js";
+import { extensionInvocation, OperatorExtensionRuntime } from "../domains/extensions/operator-runtime.js";
 import { formatColumns, printError, printOk } from "./shared.js";
 
 const HELP = `clio-coder extensions <command>
@@ -19,6 +20,7 @@ Manage Clio extension packages.
 Commands:
   clio-coder extensions list [--all] [--json] [--user|--project]
   clio-coder extensions discover <path> [--json]
+  clio-coder extensions run <id> <command> [--json] -- [arguments]
   clio-coder extensions install <path> [--user|--project] [--force] [--json]
   clio-coder extensions enable <id> [--user|--project] [--json]
   clio-coder extensions disable <id> [--user|--project] [--json]
@@ -37,7 +39,16 @@ interface Parsed {
 
 function parse(argv: ReadonlyArray<string>): Parsed {
 	const out: Parsed = { positional: [], json: false, all: false, force: false, help: false };
+	let argumentsOnly = false;
 	for (const arg of argv) {
+		if (argumentsOnly) {
+			out.positional.push(arg);
+			continue;
+		}
+		if (arg === "--") {
+			argumentsOnly = true;
+			continue;
+		}
 		if (!out.command && !arg.startsWith("-")) {
 			out.command = arg;
 			continue;
@@ -85,9 +96,9 @@ function printDiagnostics(diagnostics: ReadonlyArray<ExtensionDiagnostic>): void
 	}
 }
 
-function resourceSummary(extension: InstalledExtension): string {
-	const resources = Object.entries(extension.resources).map(([key, value]) => `${key}:${value}`);
-	return resources.length > 0 ? resources.join(",") : "-";
+function toolSummary(extension: InstalledExtension): string {
+	const tools = extension.capabilities?.tools.map((tool) => tool.name) ?? [];
+	return tools.length > 0 ? tools.join(",") : "-";
 }
 
 function stateLabel(extension: InstalledExtension): string {
@@ -95,7 +106,7 @@ function stateLabel(extension: InstalledExtension): string {
 	if (!extension.compatible) return "incompatible";
 	if (!extension.enabled) return "disabled";
 	if (!extension.effective) return `shadowed:${extension.overriddenBy ?? "higher"}`;
-	return extension.loadable ? "active" : "inactive";
+	return extension.loadable ? "eligible" : "inactive";
 }
 
 function printList(items: ReadonlyArray<InstalledExtension>): void {
@@ -105,20 +116,20 @@ function printList(items: ReadonlyArray<InstalledExtension>): void {
 	}
 	process.stdout.write(
 		`${formatColumns([
-			["id", "scope", "state", "version", "resources", "description"],
+			["id", "scope", "state", "version", "tools", "description"],
 			...items.map((extension) => [
 				extension.id,
 				extension.scope,
 				stateLabel(extension),
 				extension.version,
-				resourceSummary(extension),
+				toolSummary(extension),
 				extension.description,
 			]),
 		])}\n`,
 	);
 }
 
-export function runExtensionsCommand(argv: ReadonlyArray<string>): number {
+export function runExtensionsCommand(argv: ReadonlyArray<string>): number | Promise<number> {
 	let parsed: Parsed;
 	try {
 		parsed = parse(argv);
@@ -142,6 +153,8 @@ export function runExtensionsCommand(argv: ReadonlyArray<string>): number {
 	}
 	const scopeOptions = { ...(parsed.scope ? { scope: parsed.scope } : {}) };
 	switch (parsed.command) {
+		case "run":
+			return runOperatorCommand(parsed);
 		case "list": {
 			const items = listInstalledExtensions(process.cwd(), { ...scopeOptions, all: parsed.all });
 			if (parsed.json) process.stdout.write(`${JSON.stringify({ extensions: items }, null, 2)}\n`);
@@ -178,7 +191,13 @@ export function runExtensionsCommand(argv: ReadonlyArray<string>): number {
 			if (parsed.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
 			else {
 				printDiagnostics(result.diagnostics);
-				if (result.extension) printOk(`installed ${result.extension.id} (${result.extension.scope})`);
+				if (result.extension) {
+					printOk(`installed ${result.extension.id} (${result.extension.scope})`);
+					if (result.extension.runtime)
+						process.stderr.write(
+							"Operator runtime code starts on the next interactive startup/reload or explicit extensions run. Install only code you trust; it runs with your user account authority.\n",
+						);
+				}
 			}
 			return hasErrors(result.diagnostics) ? 1 : 0;
 		}
@@ -217,3 +236,50 @@ export function runExtensionsCommand(argv: ReadonlyArray<string>): number {
 			return 2;
 	}
 }
+
+async function runOperatorCommand(parsed: Parsed): Promise<number> {
+	const [id, command, ...args] = parsed.positional;
+	if (!id || !command || parsed.scope || parsed.force || parsed.all) {
+		process.stderr.write("usage: clio-coder extensions run <id> <command> [--json] -- [arguments]\n");
+		return 2;
+	}
+	const selected = listInstalledExtensions(process.cwd(), { all: true }).find(
+		(entry) => entry.id === id && entry.loadable,
+	);
+	if (!selected?.runtime?.commands.some((entry) => entry.name === command)) {
+		printError(`extension ${id} has no eligible operator command '${command}'`);
+		return 1;
+	}
+	const runtime = new OperatorExtensionRuntime({
+		context: () => ({ workspace: process.cwd(), sessionId: null, mode: "headless" }),
+		isIdle: () => true,
+		onlyId: id,
+	});
+	const controller = new AbortController();
+	const cancel = (): void => {
+		controller.abort();
+		void runtime.dispose();
+	};
+	process.once("SIGINT", cancel);
+	process.once("SIGTERM", cancel);
+	try {
+		const reload = await runtime.reload("startup");
+		if (reload.status !== "committed") throw new Error(reload.message);
+		const provenance = runtime.entries().find((entry) => entry.id === id && entry.state === "ready")?.provenance;
+		const output = await runtime.invoke(extensionInvocation(id, command), args.join(" "), [], controller.signal);
+		if (!provenance) throw new Error("extension result has no activated provenance");
+		if (parsed.json)
+			process.stdout.write(
+				`${JSON.stringify({ extensionId: id, command, generation: reload.generation, provenance, output })}\n`,
+			);
+		else process.stdout.write(`${output.text}\n`);
+		return 0;
+	} catch (error) {
+		printError(error instanceof Error ? error.message : String(error));
+		return 1;
+	} finally {
+		process.off("SIGINT", cancel);
+		process.off("SIGTERM", cancel);
+		await runtime.dispose();
+	}
+}

package/src/cli/fleet-preflight.ts

@@ -54,6 +54,8 @@ export function inspectFleet(name: string, vars?: Readonly<Record<string, string
 		}
 	}
 	const plan = compileFleetExecutionPlan({
+		commands,
+		...(vars ? { vars } : {}),
 		contract,
 		task: prompt,
 		resolveAgent(context) {

package/src/cli/fleet.ts

@@ -393,6 +393,8 @@ async function runFleet(args: ReadonlyArray<string>): Promise<number> {
 	let plan: ExecutionPlan;
 	try {
 		plan = compileFleetExecutionPlan({
+			commands,
+			...(vars ? { vars } : {}),
 			contract,
 			task: prompt,
 			resolveAgent(context) {

package/src/cli/index.ts

@@ -69,8 +69,7 @@ Usage:
   clio-coder usage report         cross-session usage facts and opportunities (experimental)
   clio-coder trace                query or view the durable dispatch trace mirror
   clio-coder extensions           install, list, enable, disable, or remove extension packages
-  clio-coder skills               list, inspect, validate, or install skills
-  clio-coder library              list, search, add, or sync agents, prompts, fleets, and skills from catalogs
+  clio-coder library              register, install, update, import, inspect, and manage packages of every kind
   clio-coder tasks                list, add, hand, finish, or drop project operator tasks
   clio-coder verifiers            discover, inspect, author, validate, edit, or dry-run project checks
   clio-coder tools list|status|install|remove <id>  pinned external programs Clio can drive
@@ -258,7 +257,6 @@ const COMMAND_HANDLERS = new Map<string, CommandHandler>([
 	["extensions", extensionsCommand],
 	["ext", extensionsCommand],
 	["fleet", async (subArgs) => (await import("./fleet.js")).runFleetCommand(subArgs)],
-	["skills", async (subArgs) => (await import("./skills.js")).runSkillsCommand(subArgs)],
 	["library", async (subArgs) => (await import("./library.js")).runLibraryCommand(subArgs)],
 	["tasks", async (subArgs) => (await import("./tasks.js")).runTasksCommand(subArgs)],
 	["verifiers", async (subArgs) => (await import("./verifiers.js")).runVerifiersCommand(subArgs)],

package/src/cli/interop-inspect.ts

@@ -1,23 +1,3 @@
-/**
- * Fixed machine-readable projection of detected external coding agents.
- *
- * `configure --interop` is an interactive review that writes delegation peers
- * into settings, so it is not a transport a GUI host can invoke. This command
- * takes no identifier or flag beyond `--json`, decides nothing, and writes
- * nothing.
- *
- * It also runs no foreign executable. Detection can probe `<bin> --version`,
- * and this read deliberately does not: a GUI refresh must not become "execute
- * every coding agent installed on this machine". The version still crosses,
- * because a non-probing detection keeps the last version the harness observed
- * for the same binary, so what the operator sees is a recorded fact rather than
- * a fresh execution.
- *
- * Resolved binary paths and the agent's home directory are native filesystem
- * facts and stay on the host. Whether a directory exists crosses; where it is
- * does not.
- */
-
 import { readSettings } from "../core/config.js";
 import {
 	detectInteropAgents,
@@ -30,10 +10,26 @@ import {
 export type InteropDecisionState = "accepted" | "declined";
 
 export interface InteropInspectAgent {
+	readonly inventory: {
+		status: string;
+		diagnosticCount: number;
+		listing: "unknown";
+		counts: Record<string, number>;
+		items: ReadonlyArray<{
+			kind: string;
+			name: string;
+			scope: string;
+			version?: string;
+			marketplace?: string;
+			installation?: string;
+			enabled?: boolean;
+			adoption: string;
+		}>;
+	} | null;
 	readonly id: InteropAgentId;
 	readonly label: string;
 	readonly presence: InteropPresence;
-	/** The last version the harness observed for this binary, never probed here. */
+	/** The bounded version probe result, or last observed version. */
 	readonly version: string | null;
 	/** Whether the agent owns a directory under the operator's home. The path stays host-side. */
 	readonly hasUserDirectory: boolean;
@@ -65,22 +61,15 @@ export interface InteropInspectSnapshot {
 	readonly detectedAt: string;
 	/**
 	 * How many agent kinds the registry knows, so an empty list reads as "none
-	 * detected" rather than "nothing to detect". Detection drops a kind with no
-	 * binary, no directory, and no artifacts, so the list is never padded.
+	 * detected" rather than "nothing to detect". Explicit inspection includes all five inventory-enabled hosts, including absent
+	 * binaries; lightweight bootstrap detection still drops empty kinds.
 	 */
 	readonly knownKinds: number;
 	readonly agents: readonly InteropInspectAgent[];
 }
 
-/**
- * Skill and artifact counts are deliberately absent.
- *
- * Detection populates them only from sources the resources and context domains
- * have already loaded, and this command loads neither. Reporting the structural
- * zero that would result would state a fact this read did not establish.
- */
 async function interopInspectSnapshot(now: () => number = Date.now): Promise<InteropInspectSnapshot> {
-	const report = await detectInteropAgents({ cwd: process.cwd(), probeVersion: false });
+	const report = await detectInteropAgents({ cwd: process.cwd(), probeVersion: true, inventory: true });
 	const settings = readSettings();
 	const configured = new Set(settings.integrations.externalAgents.entries.map((agent) => agent.id));
 	const agents: InteropInspectAgent[] = [];
@@ -92,6 +81,27 @@ async function interopInspectSnapshot(now: () => number = Date.now): Promise<Int
 		const decisionStale = decision !== null && record.decidedFingerprint !== record.fingerprint;
 		const isConfigured = configured.has(kind.id);
 		agents.push({
+			inventory: record.inventory
+				? {
+						status: record.inventory.status,
+						diagnosticCount: record.inventory.diagnostics.length,
+						listing: record.inventory.listing,
+						counts: record.inventory.items.reduce<Record<string, number>>((counts, item) => {
+							counts[item.kind] = (counts[item.kind] ?? 0) + 1;
+							return counts;
+						}, {}),
+						items: record.inventory.items.map(({ kind, name, scope, version, marketplace, installation, enabled }) => ({
+							kind,
+							name,
+							scope,
+							...(version ? { version } : {}),
+							...(marketplace ? { marketplace } : {}),
+							...(installation ? { installation } : {}),
+							...(enabled !== undefined ? { enabled } : {}),
+							adoption: ["hook", "mcp", "executable", "output-style"].includes(kind) ? "not adoptable" : "review required",
+						})),
+					}
+				: null,
 			id: kind.id,
 			label: kind.label,
 			presence: record.presence,
@@ -119,10 +129,28 @@ async function interopInspectSnapshot(now: () => number = Date.now): Promise<Int
 }
 
 export async function runInteropInspect(args: ReadonlyArray<string>): Promise<number> {
-	if (args.length !== 1 || args[0] !== "--json") {
+	if (args.length > 1 || (args.length === 1 && args[0] !== "--json")) {
 		process.stderr.write("clio-coder interop inspect: usage: clio-coder interop inspect --json\n");
 		return 2;
 	}
-	process.stdout.write(`${JSON.stringify(await interopInspectSnapshot(), null, 2)}\n`);
+	const snapshot = await interopInspectSnapshot();
+	if (args[0] === "--json") process.stdout.write(`${JSON.stringify(snapshot, null, 2)}\n`);
+	else
+		for (const agent of snapshot.agents) {
+			process.stdout.write(
+				`${agent.label}: ${agent.presence}; version ${agent.version ?? "unknown"}; ${agent.configured ? "connected" : "not connected"}; adapter ${agent.adapter ?? "unsupported"}\n`,
+			);
+			process.stdout.write(
+				`  Inventory ${agent.inventory?.status ?? "unknown"}: ${
+					Object.entries(agent.inventory?.counts ?? {})
+						.map(([kind, count]) => `${count} ${kind}`)
+						.join(", ") || "none found"
+				}\n`,
+			);
+			for (const item of agent.inventory?.items ?? [])
+				process.stdout.write(
+					`  ${item.scope} ${item.kind} ${item.name}${item.version ? ` @ ${item.version}` : ""}${item.marketplace ? ` (${item.marketplace})` : ""}; ${item.adoption}\n`,
+				);
+		}
 	return 0;
 }

package/src/cli/interop.ts

@@ -1,11 +1,15 @@
-/**
- * `clio-coder interop`, the read half of external coding agent detection.
- *
- * Reviewing and wiring a detected agent as a delegation peer is an interactive
- * mutation and stays on `configure --interop`. This command family carries the
- * read only, and its one subcommand is the fixed projection a GUI host may run.
- */
+/** Discover coding agents and review safe resource adoption without model calls. */
 
+import { createInterface } from "node:readline/promises";
+import {
+	type AdoptionKind,
+	applyInteropAdoption,
+	detectInteropAgents,
+	type InteropAgentId,
+	interopAgentKind,
+	planInteropAdoption,
+	renderInteropAdoptionPlan,
+} from "../domains/interop/index.js";
 import { runInteropInspect } from "./interop-inspect.js";
 import { printError } from "./shared.js";
 
@@ -14,10 +18,13 @@ const HELP = `clio-coder interop <subcommand>
 Detected external coding agents and how far each one is wired.
 
 Subcommands:
-  inspect --json                emit the detected agent inventory with no native paths
+  inspect [--json]              show host inventory and connection state
+  adopt <host> [--kind skill|agent|prompt|plugin] [--project|--user]
+               [--yes] [--dry-run]
+                                review and adopt safe resources
 
 Notes:
-  inspect writes nothing and runs no foreign executable. Wiring a detected agent
+  inspect changes no host or project files and starts no agent session. Wiring a detected agent
   as a delegation peer is an explicit review: run \`clio-coder configure --interop\`.
 `;
 
@@ -27,8 +34,71 @@ export async function runInteropCommand(args: ReadonlyArray<string>): Promise<nu
 		process.stdout.write(HELP);
 		return sub === undefined ? 2 : 0;
 	}
+	if (sub === "adopt") return await runAdopt(args.slice(1));
 	if (sub === "inspect") return await runInteropInspect(args.slice(1));
 	printError(`unknown interop command: ${sub}`);
 	process.stdout.write(HELP);
 	return 2;
 }
+
+async function runAdopt(args: ReadonlyArray<string>): Promise<number> {
+	const host = args[0] === "claude" ? "claude-code" : args[0] === "agy" ? "antigravity" : args[0];
+	const kind = host ? interopAgentKind(host as InteropAgentId) : undefined;
+	if (!kind?.inventory) {
+		printError("adopt requires a host: claude-code, codex, antigravity, copilot, opencode");
+		return 2;
+	}
+	let filter: AdoptionKind | undefined;
+	let scope: "user" | "project" | undefined;
+	let yes = false;
+	let dryRun = false;
+	for (let i = 1; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--kind") {
+			const next = args[++i];
+			if (!next || !["skill", "agent", "prompt", "plugin"].includes(next)) {
+				printError("invalid adoption kind");
+				return 2;
+			}
+			filter = next as AdoptionKind;
+		} else if (arg === "--project" || arg === "--user") {
+			if (scope) {
+				printError("choose one destination scope");
+				return 2;
+			}
+			scope = arg === "--project" ? "project" : "user";
+		} else if (arg === "--yes") yes = true;
+		else if (arg === "--dry-run") dryRun = true;
+		else {
+			printError(`unknown adopt option: ${arg}`);
+			return 2;
+		}
+	}
+	const report = await detectInteropAgents({ inventory: true });
+	const inventory = report.agents.find((agent) => agent.kind === kind.id)?.inventory;
+	if (!inventory) {
+		printError("inventory is unknown");
+		return 1;
+	}
+	const plan = planInteropAdoption({
+		host: kind.id,
+		inventory,
+		...(scope ? { scope } : {}),
+		...(filter ? { kind: filter } : {}),
+	});
+	process.stdout.write(`${renderInteropAdoptionPlan(plan)}\n`);
+	for (const diagnostic of inventory.diagnostics) process.stdout.write(`Unknown: ${diagnostic}\n`);
+	if (dryRun || !plan.entries.some((entry) => entry.action === "install")) return 0;
+	if (!yes && process.stdin.isTTY && process.stdout.isTTY) {
+		const rl = createInterface({ input: process.stdin, output: process.stdout });
+		try {
+			yes = (await rl.question("Install this plan? [y/N] ")).trim().toLowerCase() === "y";
+		} finally {
+			rl.close();
+		}
+	}
+	const result = applyInteropAdoption(plan, yes);
+	for (const id of result.installed) process.stdout.write(`Installed ${id}\n`);
+	for (const diagnostic of result.diagnostics) process.stderr.write(`${diagnostic}\n`);
+	return result.diagnostics.length > 0 ? 1 : 0;
+}