@iowarp/clio-coder 0.4.6 → 0.4.8

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

@@ -29,6 +29,7 @@ science. CLIO stands for Context Layer for Input/Output, named for the Greek mus
 
 Usage:
   clio-coder                      start interactive repository chat
+  clio-coder web [--open]         start the browser application
   clio-coder acp                  serve Clio as an ACP v1 agent over stdio
   clio-coder --acp                alias for clio-coder acp
   clio-coder run [flags] <task>   run one headless main-agent turn
@@ -69,14 +70,13 @@ 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
   clio-coder interop inspect --json  detected external coding agents and how far each one is wired
   clio-coder panes install|theme  install the pane multiplexer (alias for 'tools install herdr'), or print Clio's theme as a herdr block
-  clio-coder docs [topic]         serve the HTML docs of a source checkout on 127.0.0.1 (--no-open to skip browser)
+  clio-coder docs [topic]         open documentation in the web app (--no-open to print the launch link)
   clio-coder dev <command>        harness instruments; run 'clio-coder dev' for the list
   clio-coder --help, -h           this message
   clio-coder --help --all         this message plus every command under 'clio-coder dev'
@@ -258,10 +258,10 @@ 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)],
+	["web", async (subArgs) => (await import("./web.js")).runWebCommand(subArgs)],
 	["docs", async (subArgs) => (await import("./docs.js")).runDocsCommand(subArgs)],
 	["share", async (subArgs) => (await import("./share.js")).runShareCommand(subArgs)],
 	["export", async (subArgs) => (await import("./share.js")).runExportCommand(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;
+}

package/src/cli/library-import.ts

@@ -0,0 +1,139 @@
+/** Explicit foreign or portable package import with the same review shape as interop adopt. */
+
+import { createInterface } from "node:readline/promises";
+import { readSettings } from "../core/config.js";
+import {
+	applyLibraryImport,
+	type LibraryImportPlan,
+	libraryImportPlanSummary,
+	planLibraryImport,
+	releaseLibraryImport,
+	renderLibraryImportPlan,
+} from "../domains/interop/index.js";
+import { printError } from "./shared.js";
+
+const HELP = `clio-coder library import <path|github-tree-url> [--user|--project] [--format claude|codex] [--dry-run] [--json] [--yes]
+
+Review and import a plugin package from a local directory or a GitHub tree URL
+(https://github.com/owner/repo/tree/ref/path). A portable root plugin.json is
+imported as-is (data only). A .claude-plugin/plugin.json or .codex-plugin/plugin.json
+package is normalized into a portable Clio package: skills keep their text and
+frontmatter names, command markdown becomes prompt recipes, Claude agents become
+read-only Clio agents. Hooks, MCP, LSP, scripts and host settings are reported and
+never activated. Imported packages keep foreign trust; --format disambiguates when
+both hidden manifests exist. Source files are never changed.
+`;
+
+interface Parsed {
+	source?: string;
+	scope?: "user" | "project";
+	format?: "claude-code" | "codex";
+	dryRun: boolean;
+	json: boolean;
+	yes: boolean;
+	help: boolean;
+}
+
+function parse(args: ReadonlyArray<string>): Parsed {
+	const out: Parsed = { dryRun: false, json: false, yes: false, help: false };
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (!arg) continue;
+		if (arg === "--help" || arg === "-h") out.help = true;
+		else if (arg === "--json") out.json = true;
+		else if (arg === "--yes") out.yes = true;
+		else if (arg === "--dry-run") out.dryRun = true;
+		else if (arg === "--user" || arg === "--project") {
+			const scope = arg === "--user" ? "user" : "project";
+			if (out.scope && out.scope !== scope) throw new Error("--user and --project are mutually exclusive");
+			out.scope = scope;
+		} else if (arg === "--format") {
+			const value = args[++i];
+			const format =
+				value === "claude" || value === "claude-code" ? "claude-code" : value === "codex" ? "codex" : undefined;
+			if (!format) throw new Error("--format requires claude or codex");
+			out.format = format;
+		} else if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+		else if (out.source) throw new Error("library import takes exactly one path or GitHub tree URL");
+		else out.source = arg;
+	}
+	return out;
+}
+
+export async function runLibraryImport(args: ReadonlyArray<string>): Promise<number> {
+	let parsed: Parsed;
+	try {
+		parsed = parse(args);
+	} catch (error) {
+		printError(error instanceof Error ? error.message : String(error));
+		return 2;
+	}
+	if (parsed.help || !parsed.source) {
+		process.stdout.write(HELP);
+		return parsed.help ? 0 : 2;
+	}
+	const emit = (value: unknown): void => {
+		process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+	};
+	let plan: LibraryImportPlan;
+	try {
+		plan = planLibraryImport(parsed.source, {
+			cwd: process.cwd(),
+			...(parsed.scope ? { scope: parsed.scope } : {}),
+			...(parsed.format ? { format: parsed.format } : {}),
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (parsed.json) emit({ ok: false, error: message });
+		else printError(message);
+		return 1;
+	}
+	try {
+		if (!parsed.json) process.stdout.write(`${renderLibraryImportPlan(plan)}\n`);
+		if (parsed.dryRun || plan.action !== "install") {
+			if (parsed.json) emit({ ok: plan.action === "install", confirmed: false, plan: libraryImportPlanSummary(plan) });
+			return plan.action === "install" ? 0 : 1;
+		}
+		let yes = parsed.yes;
+		if (!yes && !parsed.json && process.stdin.isTTY && process.stdout.isTTY) {
+			const rl = createInterface({ input: process.stdin, output: process.stdout });
+			try {
+				yes = (await rl.question("Import this plan? [y/N] ")).trim().toLowerCase() === "y";
+			} finally {
+				rl.close();
+			}
+		}
+		let trustProjectImports: boolean | undefined;
+		try {
+			trustProjectImports = readSettings().integrations.projectResources.trustProjectImports === true;
+		} catch {
+			trustProjectImports = undefined;
+		}
+		const summary = libraryImportPlanSummary(plan);
+		const result = applyLibraryImport(plan, yes, trustProjectImports === undefined ? {} : { trustProjectImports });
+		plan = { ...plan, cleanup: () => {} };
+		if (parsed.json) emit({ ok: result.published, confirmed: yes, plan: summary, result });
+		else {
+			if (result.installed) process.stdout.write(`Installed ${result.installed} at ${result.destination}\n`);
+			if (result.validation) {
+				const count = result.validation.validation.resources.length;
+				process.stdout.write(
+					`${result.validation.valid ? "Validated" : "Validation failed for"} ${count} installed resource${count === 1 ? "" : "s"}\n`,
+				);
+				for (const diagnostic of result.validation.validation.diagnostics)
+					process.stderr.write(
+						`  [${diagnostic.code}] ${diagnostic.message}${diagnostic.path ? ` (${diagnostic.path})` : ""}\n`,
+					);
+			}
+			process.stdout.write(
+				`Trust: foreign; trust gate ${result.admission.gate} is ${
+					result.admission.gateEnabled === "unknown" ? "unread" : result.admission.gateEnabled ? "enabled" : "disabled"
+				}; runtime availability is reported by the library inventory\n`,
+			);
+			for (const diagnostic of result.diagnostics) process.stderr.write(`${diagnostic}\n`);
+		}
+		return result.published && (result.validation?.valid ?? true) && result.diagnostics.length === 0 ? 0 : 1;
+	} finally {
+		releaseLibraryImport(plan);
+	}
+}