@pixelzx/genesis 2026.7.8 → 2026.7.9

package/dist/capability-cli-n36Okw1e.js

@@ -0,0 +1,1401 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString, d as normalizeStringifiedOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { n as defaultRuntime, r as writeRuntimeJson } from "./runtime-DDkDH9fa.js";
+import { t as formatDocsLink } from "./links-C1-jbHJx.js";
+import { r as theme } from "./theme-DD6pQv2_.js";
+import { a as isLoopbackHost } from "./net-BzaeD_3Q.js";
+import { a as loadConfig } from "./io-Cy5vajWd.js";
+import { t as getProviderEnvVars } from "./provider-env-vars-DDxo5bUJ.js";
+import { n as resolveAgentModelPrimaryValue } from "./model-input-gXkzehoL.js";
+import { x as resolveDefaultAgentId, y as resolveAgentDir } from "./agent-scope-BUYwVohk.js";
+import "./config-DYHZ3jG1.js";
+import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES } from "./client-info-CjxzJxIU.js";
+import { f as updateAuthProfileStoreWithLock, s as loadAuthProfileStoreForRuntime } from "./store-DOYGPxaT.js";
+import { a as registerMemoryEmbeddingProvider, r as listMemoryEmbeddingProviders } from "./memory-embedding-providers-CKYjkNxa.js";
+import { r as loadModelCatalog } from "./model-catalog-bbYPQYGY.js";
+import { l as normalizeMimeType, n as extensionForMime, t as detectMime } from "./mime-uYFJ8ocK.js";
+import { S as setTtsProvider, b as setTtsEnabled, f as resolveExplicitTtsOverrides, h as resolveTtsPrefsPath, m as resolveTtsConfig, o as getTtsProvider, u as listSpeechVoices, w as textToSpeech } from "./tts-DkAzfFXU.js";
+import { a as getImageMetadata } from "./image-ops-BKoz9hKm.js";
+import "./auth-profiles-COE8qycx.js";
+import { n as listProfilesForProvider } from "./profile-list-C0rD0kln.js";
+import { t as buildGatewayConnectionDetailsWithResolvers } from "./connection-details-CtgHGqRU.js";
+import { c as randomIdempotencyKey, r as callGateway } from "./call-CoL9QpLf.js";
+import { n as listRuntimeImageGenerationProviders, t as generateImage } from "./runtime-JVOgkIEF.js";
+import { l as saveMediaBuffer } from "./store-Il9HLBFt.js";
+import { C as buildMediaUnderstandingRegistry } from "./resolve-BHmKuinY.js";
+import { n as listRuntimeVideoGenerationProviders, t as generateVideo } from "./runtime-CYvH_wW3.js";
+import { r as listWebSearchProviders, s as runWebSearch, t as isWebSearchProviderConfigured } from "./runtime-rxWAKdda.js";
+import { t as resolveMemorySearchConfig } from "./memory-search-CRBsqyv-.js";
+import { n as agentCommand } from "./agent-command-ByKQHVY7.js";
+import { r as listSpeechProviders, t as canonicalizeSpeechProviderId } from "./provider-registry-CkTwScxf.js";
+import { n as runCommandWithRuntime } from "./cli-utils-DpTqGaPI.js";
+import { a as transcribeAudioFile, n as describeImageFileWithModel, r as describeVideoFile, t as describeImageFile } from "./runtime-BshnyUPo.js";
+import "./provider-auth-login-D4MC4bs_.js";
+import { t as createDefaultDeps } from "./deps-CMhJYvQj.js";
+import "./aliases-Bx--0eZ4.js";
+import { n as modelsAuthLoginCommand } from "./auth-MA9UN5hQ.js";
+import "./auth-order-BTnSGQgv.js";
+import "./fallbacks-CNYcJGsI.js";
+import "./image-fallbacks-Dw2qDUfx.js";
+import { t as modelsStatusCommand } from "./list-O4TnoMHO.js";
+import "./scan-DFZp_kSW.js";
+import "./set-Cc1dUWr4.js";
+import "./set-image-BKyYldxD.js";
+import { i as registerBuiltInMemoryEmbeddingProviders, t as createEmbeddingProvider } from "./memory-core-bundled-runtime-BhqqrQ2X.js";
+import { i as resolveWebFetchDefinition, r as listWebFetchProviders, t as isWebFetchProviderConfigured } from "./runtime-CXvhncRs.js";
+import { t as removeCommandByName } from "./command-tree-CbrFdBsj.js";
+import { t as collectOption } from "./helpers-smRZ1xtJ.js";
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+//#region src/cli/capability-cli.ts
+const CAPABILITY_METADATA = [
+	{
+		id: "model.run",
+		description: "Run a one-shot text inference turn through the agent runtime.",
+		transports: ["local", "gateway"],
+		flags: [
+			"--prompt",
+			"--model",
+			"--local",
+			"--gateway",
+			"--json"
+		],
+		resultShape: "normalized payloads plus provider/model attribution"
+	},
+	{
+		id: "model.list",
+		description: "List known models from the model catalog.",
+		transports: ["local"],
+		flags: ["--json"],
+		resultShape: "catalog entries"
+	},
+	{
+		id: "model.inspect",
+		description: "Inspect one model catalog entry.",
+		transports: ["local"],
+		flags: ["--model", "--json"],
+		resultShape: "single catalog entry"
+	},
+	{
+		id: "model.providers",
+		description: "List model providers discovered from the catalog.",
+		transports: ["local"],
+		flags: ["--json"],
+		resultShape: "provider ids with counts and defaults"
+	},
+	{
+		id: "model.auth.login",
+		description: "Run the existing provider auth login flow.",
+		transports: ["local"],
+		flags: ["--provider"],
+		resultShape: "interactive auth result"
+	},
+	{
+		id: "model.auth.logout",
+		description: "Remove saved auth profiles for one provider.",
+		transports: ["local"],
+		flags: ["--provider", "--json"],
+		resultShape: "removed profile ids"
+	},
+	{
+		id: "model.auth.status",
+		description: "Show configured model auth state.",
+		transports: ["local"],
+		flags: ["--json"],
+		resultShape: "model status summary"
+	},
+	{
+		id: "image.generate",
+		description: "Generate raster images with configured image providers.",
+		transports: ["local"],
+		flags: [
+			"--prompt",
+			"--model",
+			"--count",
+			"--size",
+			"--aspect-ratio",
+			"--resolution",
+			"--output",
+			"--json"
+		],
+		resultShape: "saved image files plus attempts"
+	},
+	{
+		id: "image.edit",
+		description: "Generate edited images from one or more input files.",
+		transports: ["local"],
+		flags: [
+			"--file",
+			"--prompt",
+			"--model",
+			"--output",
+			"--json"
+		],
+		resultShape: "saved image files plus attempts"
+	},
+	{
+		id: "image.describe",
+		description: "Describe one image file through media-understanding providers.",
+		transports: ["local"],
+		flags: [
+			"--file",
+			"--prompt",
+			"--model",
+			"--json"
+		],
+		resultShape: "normalized text output"
+	},
+	{
+		id: "image.describe-many",
+		description: "Describe multiple image files independently.",
+		transports: ["local"],
+		flags: [
+			"--file",
+			"--prompt",
+			"--model",
+			"--json"
+		],
+		resultShape: "one text output per file"
+	},
+	{
+		id: "image.providers",
+		description: "List image generation providers.",
+		transports: ["local"],
+		flags: ["--json"],
+		resultShape: "provider ids and defaults"
+	},
+	{
+		id: "audio.transcribe",
+		description: "Transcribe one audio file.",
+		transports: ["local"],
+		flags: [
+			"--file",
+			"--model",
+			"--json"
+		],
+		resultShape: "normalized text output"
+	},
+	{
+		id: "audio.providers",
+		description: "List audio transcription providers.",
+		transports: ["local"],
+		flags: ["--json"],
+		resultShape: "provider ids and capabilities"
+	},
+	{
+		id: "tts.convert",
+		description: "Convert text to speech.",
+		transports: ["local", "gateway"],
+		flags: [
+			"--text",
+			"--channel",
+			"--voice",
+			"--model",
+			"--output",
+			"--local",
+			"--gateway",
+			"--json"
+		],
+		resultShape: "saved audio file plus attempts"
+	},
+	{
+		id: "tts.voices",
+		description: "List voices for a speech provider.",
+		transports: ["local"],
+		flags: ["--provider", "--json"],
+		resultShape: "voice entries"
+	},
+	{
+		id: "tts.providers",
+		description: "List speech providers.",
+		transports: ["local", "gateway"],
+		flags: [
+			"--local",
+			"--gateway",
+			"--json"
+		],
+		resultShape: "provider ids, configured state, models, voices"
+	},
+	{
+		id: "tts.status",
+		description: "Show gateway-managed TTS state.",
+		transports: ["gateway"],
+		flags: ["--gateway", "--json"],
+		resultShape: "enabled/provider state"
+	},
+	{
+		id: "tts.enable",
+		description: "Enable TTS in prefs.",
+		transports: ["local", "gateway"],
+		flags: [
+			"--local",
+			"--gateway",
+			"--json"
+		],
+		resultShape: "enabled state"
+	},
+	{
+		id: "tts.disable",
+		description: "Disable TTS in prefs.",
+		transports: ["local", "gateway"],
+		flags: [
+			"--local",
+			"--gateway",
+			"--json"
+		],
+		resultShape: "enabled state"
+	},
+	{
+		id: "tts.set-provider",
+		description: "Set the active TTS provider.",
+		transports: ["local", "gateway"],
+		flags: [
+			"--provider",
+			"--local",
+			"--gateway",
+			"--json"
+		],
+		resultShape: "selected provider"
+	},
+	{
+		id: "video.generate",
+		description: "Generate video files with configured video providers.",
+		transports: ["local"],
+		flags: [
+			"--prompt",
+			"--model",
+			"--output",
+			"--json"
+		],
+		resultShape: "saved video files plus attempts"
+	},
+	{
+		id: "video.describe",
+		description: "Describe one video file through media-understanding providers.",
+		transports: ["local"],
+		flags: [
+			"--file",
+			"--model",
+			"--json"
+		],
+		resultShape: "normalized text output"
+	},
+	{
+		id: "video.providers",
+		description: "List video generation and description providers.",
+		transports: ["local"],
+		flags: ["--json"],
+		resultShape: "provider ids and defaults"
+	},
+	{
+		id: "web.search",
+		description: "Run provider-backed web search.",
+		transports: ["local"],
+		flags: [
+			"--query",
+			"--provider",
+			"--limit",
+			"--json"
+		],
+		resultShape: "search provider result"
+	},
+	{
+		id: "web.fetch",
+		description: "Fetch URL content through configured web fetch providers.",
+		transports: ["local"],
+		flags: [
+			"--url",
+			"--provider",
+			"--format",
+			"--json"
+		],
+		resultShape: "fetch provider result"
+	},
+	{
+		id: "web.providers",
+		description: "List web search and fetch providers.",
+		transports: ["local"],
+		flags: ["--json"],
+		resultShape: "provider ids grouped by family"
+	},
+	{
+		id: "embedding.create",
+		description: "Create embeddings through embedding providers.",
+		transports: ["local"],
+		flags: [
+			"--text",
+			"--provider",
+			"--model",
+			"--json"
+		],
+		resultShape: "vectors with provider/model attribution"
+	},
+	{
+		id: "embedding.providers",
+		description: "List embedding providers.",
+		transports: ["local"],
+		flags: ["--json"],
+		resultShape: "provider ids and default models"
+	}
+];
+function findCapabilityMetadata(id) {
+	return CAPABILITY_METADATA.find((entry) => entry.id === id);
+}
+function resolveTransport(opts) {
+	if (opts.local && opts.gateway) throw new Error("Pass only one of --local or --gateway.");
+	if (opts.local) {
+		if (!opts.supported.includes("local")) throw new Error("This command does not support --local.");
+		return "local";
+	}
+	if (opts.gateway) {
+		if (!opts.supported.includes("gateway")) throw new Error("This command does not support --gateway.");
+		return "gateway";
+	}
+	return opts.defaultTransport;
+}
+function emitJsonOrText(runtime, json, value, textFormatter) {
+	if (json) {
+		writeRuntimeJson(runtime, value);
+		return;
+	}
+	runtime.log(textFormatter(value));
+}
+function formatEnvelopeForText(value) {
+	const envelope = value;
+	if (!envelope.ok) return `${envelope.capability} failed: ${envelope.error ?? "unknown error"}`;
+	const lines = [
+		`${envelope.capability} via ${envelope.transport}`,
+		...envelope.provider ? [`provider: ${envelope.provider}`] : [],
+		...envelope.model ? [`model: ${envelope.model}`] : [],
+		`outputs: ${String(envelope.outputs.length)}`
+	];
+	for (const output of envelope.outputs) {
+		const pathValue = typeof output.path === "string" ? output.path : void 0;
+		const textValue = typeof output.text === "string" ? output.text : void 0;
+		if (pathValue) lines.push(pathValue);
+		else if (textValue) lines.push(textValue);
+		else lines.push(JSON.stringify(output));
+	}
+	return lines.join("\n");
+}
+function providerSummaryText(value) {
+	return value.map((entry) => JSON.stringify(entry)).join("\n");
+}
+function hasOwnKeys(value) {
+	return Boolean(value && typeof value === "object" && Object.keys(value).length > 0);
+}
+function resolveSelectedProviderFromModelRef(modelRef) {
+	return resolveModelRefOverride(modelRef).provider;
+}
+function getAuthProfileIdsForProvider(cfg, providerId) {
+	return listProfilesForProvider(loadAuthProfileStoreForRuntime(resolveAgentDir(cfg, resolveDefaultAgentId(cfg))), providerId);
+}
+function providerHasGenericConfig(params) {
+	const modelsProviders = params.cfg.models?.providers ?? {};
+	const pluginEntries = params.cfg.plugins?.entries ?? {};
+	const ttsProviders = params.cfg.messages?.tts?.providers ?? {};
+	const envConfigured = (params.envVars ?? []).some((envVar) => Boolean(process.env[envVar]?.trim()));
+	return getAuthProfileIdsForProvider(params.cfg, params.providerId).length > 0 || hasOwnKeys(modelsProviders[params.providerId]) || hasOwnKeys(pluginEntries[params.providerId]?.config) || hasOwnKeys(ttsProviders[params.providerId]) || envConfigured;
+}
+async function writeOutputAsset(params) {
+	if (!params.outputPath) {
+		const saved = await saveMediaBuffer(params.buffer, params.mimeType, params.subdir, Number.MAX_SAFE_INTEGER, params.originalFilename);
+		return {
+			path: saved.path,
+			mimeType: saved.contentType,
+			size: saved.size
+		};
+	}
+	const resolvedOutput = path.resolve(params.outputPath);
+	const parsed = path.parse(resolvedOutput);
+	const detectedMime = await detectMime({
+		buffer: params.buffer,
+		headerMime: params.mimeType
+	}) ?? params.mimeType;
+	const requestedMime = normalizeMimeType(await detectMime({ filePath: resolvedOutput }));
+	const detectedNormalized = normalizeMimeType(detectedMime);
+	const canonicalDetectedExt = extensionForMime(detectedNormalized);
+	const fallbackExt = parsed.ext || path.extname(params.originalFilename ?? "") || "";
+	const ext = parsed.ext && requestedMime === detectedNormalized ? parsed.ext : canonicalDetectedExt ?? fallbackExt;
+	const filePath = params.outputCount <= 1 ? path.join(parsed.dir, `${parsed.name}${ext}`) : path.join(parsed.dir, `${parsed.name}-${String(params.outputIndex + 1)}${ext}`);
+	await fs$1.mkdir(path.dirname(filePath), { recursive: true });
+	await fs$1.writeFile(filePath, params.buffer);
+	return {
+		path: filePath,
+		mimeType: detectedNormalized ?? params.mimeType,
+		size: params.buffer.byteLength
+	};
+}
+async function readInputFiles(files) {
+	return await Promise.all(files.map(async (filePath) => ({
+		path: path.resolve(filePath),
+		buffer: await fs$1.readFile(path.resolve(filePath))
+	})));
+}
+function resolveModelRefOverride(raw) {
+	const trimmed = raw?.trim();
+	if (!trimmed) return {};
+	const slash = trimmed.indexOf("/");
+	if (slash <= 0 || slash === trimmed.length - 1) return { model: trimmed };
+	return {
+		provider: trimmed.slice(0, slash),
+		model: trimmed.slice(slash + 1)
+	};
+}
+function requireProviderModelOverride(raw) {
+	const resolved = resolveModelRefOverride(raw);
+	if (!raw?.trim()) return;
+	if (!resolved.provider || !resolved.model) throw new Error("Model overrides must use the form <provider/model>.");
+	return {
+		provider: resolved.provider,
+		model: resolved.model
+	};
+}
+async function runModelRun(params) {
+	const agentId = resolveDefaultAgentId(loadConfig());
+	if (params.transport === "local") {
+		const result = await agentCommand({
+			message: params.prompt,
+			agentId,
+			model: params.model,
+			json: false
+		}, {
+			...defaultRuntime,
+			log: () => {}
+		}, createDefaultDeps());
+		return {
+			ok: true,
+			capability: "model.run",
+			transport: "local",
+			provider: result?.meta?.agentMeta?.provider,
+			model: result?.meta?.agentMeta?.model,
+			attempts: [],
+			outputs: (result?.payloads ?? []).map((payload) => ({
+				text: payload.text,
+				mediaUrl: payload.mediaUrl,
+				mediaUrls: payload.mediaUrls
+			}))
+		};
+	}
+	const { provider, model } = resolveModelRefOverride(params.model);
+	const response = await callGateway({
+		method: "agent",
+		params: {
+			agentId,
+			message: params.prompt,
+			provider,
+			model,
+			idempotencyKey: randomIdempotencyKey()
+		},
+		expectFinal: true,
+		timeoutMs: 12e4,
+		clientName: GATEWAY_CLIENT_NAMES.CLI,
+		mode: GATEWAY_CLIENT_MODES.CLI
+	});
+	return {
+		ok: true,
+		capability: "model.run",
+		transport: "gateway",
+		provider: response?.result?.meta?.agentMeta?.provider,
+		model: response?.result?.meta?.agentMeta?.model,
+		attempts: [],
+		outputs: (response?.result?.payloads ?? []).map((payload) => ({
+			text: payload.text,
+			mediaUrl: payload.mediaUrl,
+			mediaUrls: payload.mediaUrls
+		}))
+	};
+}
+async function buildModelProviders() {
+	const cfg = loadConfig();
+	const catalog = await loadModelCatalog({ config: cfg });
+	const selectedProvider = resolveSelectedProviderFromModelRef(resolveAgentModelPrimaryValue(cfg.agents?.defaults?.model));
+	const grouped = /* @__PURE__ */ new Map();
+	for (const entry of catalog) {
+		const current = grouped.get(entry.provider) ?? {
+			provider: entry.provider,
+			count: 0,
+			defaults: [],
+			available: true,
+			configured: providerHasGenericConfig({
+				cfg,
+				providerId: entry.provider
+			}),
+			selected: selectedProvider === entry.provider
+		};
+		current.count += 1;
+		if (current.defaults.length < 3) current.defaults.push(entry.id);
+		grouped.set(entry.provider, current);
+	}
+	return [...grouped.values()].toSorted((a, b) => a.provider.localeCompare(b.provider));
+}
+async function runModelAuthStatus() {
+	const captured = [];
+	await modelsStatusCommand({ json: true }, {
+		log: (...args) => captured.push(args.join(" ")),
+		error: (message) => {
+			throw message instanceof Error ? message : new Error(String(message));
+		},
+		exit: (code) => {
+			throw new Error(`exit ${code}`);
+		}
+	});
+	const raw = captured.find((line) => line.trim().startsWith("{"));
+	return raw ? JSON.parse(raw) : {};
+}
+async function runModelAuthLogout(provider) {
+	const cfg = loadConfig();
+	const agentDir = resolveAgentDir(cfg, resolveDefaultAgentId(cfg));
+	const profileIds = listProfilesForProvider(loadAuthProfileStoreForRuntime(agentDir), provider);
+	if (!await updateAuthProfileStoreWithLock({
+		agentDir,
+		updater: (nextStore) => {
+			let changed = false;
+			for (const profileId of profileIds) {
+				if (nextStore.profiles[profileId]) {
+					delete nextStore.profiles[profileId];
+					changed = true;
+				}
+				if (nextStore.usageStats?.[profileId]) {
+					delete nextStore.usageStats[profileId];
+					changed = true;
+				}
+			}
+			if (nextStore.order?.[provider]) {
+				delete nextStore.order[provider];
+				changed = true;
+			}
+			if (nextStore.lastGood?.[provider]) {
+				delete nextStore.lastGood[provider];
+				changed = true;
+			}
+			return changed;
+		}
+	})) throw new Error(`Failed to remove saved auth profiles for provider ${provider}.`);
+	return {
+		provider,
+		removedProfiles: profileIds
+	};
+}
+async function runImageGenerate(params) {
+	const cfg = loadConfig();
+	const agentDir = resolveAgentDir(cfg, resolveDefaultAgentId(cfg));
+	const inputImages = params.file && params.file.length > 0 ? await Promise.all((await readInputFiles(params.file)).map(async (entry) => ({
+		buffer: entry.buffer,
+		fileName: path.basename(entry.path),
+		mimeType: await detectMime({
+			buffer: entry.buffer,
+			filePath: entry.path
+		}) ?? "image/png"
+	}))) : void 0;
+	const result = await generateImage({
+		cfg,
+		agentDir,
+		prompt: params.prompt,
+		modelOverride: params.model,
+		count: params.count,
+		size: params.size,
+		aspectRatio: params.aspectRatio,
+		resolution: params.resolution,
+		inputImages
+	});
+	const outputs = await Promise.all(result.images.map(async (image, index) => {
+		const written = await writeOutputAsset({
+			buffer: image.buffer,
+			mimeType: image.mimeType,
+			originalFilename: image.fileName,
+			outputPath: params.output,
+			outputIndex: index,
+			outputCount: result.images.length,
+			subdir: "generated"
+		});
+		const metadata = await getImageMetadata(image.buffer).catch(() => void 0);
+		return {
+			...written,
+			width: metadata?.width,
+			height: metadata?.height,
+			revisedPrompt: image.revisedPrompt
+		};
+	}));
+	return {
+		ok: true,
+		capability: params.capability,
+		transport: "local",
+		provider: result.provider,
+		model: result.model,
+		attempts: result.attempts,
+		outputs
+	};
+}
+async function runImageDescribe(params) {
+	const cfg = loadConfig();
+	const agentDir = resolveAgentDir(cfg, resolveDefaultAgentId(cfg));
+	const activeModel = requireProviderModelOverride(params.model);
+	const outputs = await Promise.all(params.files.map(async (filePath) => {
+		const resolvedPath = path.resolve(filePath);
+		const result = activeModel ? await describeImageFileWithModel({
+			filePath: resolvedPath,
+			cfg,
+			agentDir,
+			provider: activeModel.provider,
+			model: activeModel.model,
+			prompt: "Describe the image."
+		}) : await describeImageFile({
+			filePath: resolvedPath,
+			cfg,
+			agentDir
+		});
+		if (!result.text) throw new Error(`No description returned for image: ${resolvedPath}`);
+		return {
+			path: resolvedPath,
+			text: result.text,
+			provider: activeModel?.provider ?? ("provider" in result ? result.provider : void 0),
+			model: result.model,
+			kind: "image.description"
+		};
+	}));
+	return {
+		ok: true,
+		capability: params.capability,
+		transport: "local",
+		provider: outputs[0]?.provider,
+		model: outputs[0]?.model,
+		attempts: [],
+		outputs
+	};
+}
+async function runAudioTranscribe(params) {
+	const cfg = loadConfig();
+	const activeModel = requireProviderModelOverride(params.model);
+	const result = await transcribeAudioFile({
+		filePath: path.resolve(params.file),
+		cfg,
+		language: params.language,
+		activeModel,
+		prompt: params.prompt
+	});
+	if (!result.text) throw new Error(`No transcript returned for audio: ${path.resolve(params.file)}`);
+	return {
+		ok: true,
+		capability: "audio.transcribe",
+		transport: "local",
+		attempts: [],
+		outputs: [{
+			path: path.resolve(params.file),
+			text: result.text,
+			kind: "audio.transcription"
+		}]
+	};
+}
+async function runVideoGenerate(params) {
+	const cfg = loadConfig();
+	const result = await generateVideo({
+		cfg,
+		agentDir: resolveAgentDir(cfg, resolveDefaultAgentId(cfg)),
+		prompt: params.prompt,
+		modelOverride: params.model
+	});
+	const outputs = await Promise.all(result.videos.map(async (video, index) => {
+		if (!video.buffer && !video.url) throw new Error(`Video asset at index ${index} has neither buffer nor url`);
+		let videoBuffer = video.buffer;
+		if (!videoBuffer && video.url) {
+			const response = await fetch(video.url, { signal: AbortSignal.timeout(12e4) });
+			if (!response.ok) throw new Error(`Failed to download video from ${video.url}: ${response.status}`);
+			if (params.output && response.body) {
+				const ext = extensionForMime(normalizeMimeType(video.mimeType)) || path.extname(video.fileName ?? "") || path.extname(params.output ?? "");
+				const resolvedOutput = path.resolve(params.output);
+				const parsed = path.parse(resolvedOutput);
+				const filePath = result.videos.length <= 1 ? path.join(parsed.dir, `${parsed.name}${ext}`) : path.join(parsed.dir, `${parsed.name}-${String(index + 1)}${ext}`);
+				await fs$1.mkdir(path.dirname(filePath), { recursive: true });
+				await pipeline(Readable.fromWeb(response.body), createWriteStream(filePath));
+				const stat = await fs$1.stat(filePath);
+				return {
+					path: filePath,
+					mimeType: video.mimeType,
+					size: stat.size
+				};
+			}
+			videoBuffer = Buffer.from(await response.arrayBuffer());
+		}
+		return { ...await writeOutputAsset({
+			buffer: videoBuffer,
+			mimeType: video.mimeType,
+			originalFilename: video.fileName,
+			outputPath: params.output,
+			outputIndex: index,
+			outputCount: result.videos.length,
+			subdir: "generated"
+		}) };
+	}));
+	return {
+		ok: true,
+		capability: "video.generate",
+		transport: "local",
+		provider: result.provider,
+		model: result.model,
+		attempts: result.attempts,
+		outputs
+	};
+}
+async function runVideoDescribe(params) {
+	const cfg = loadConfig();
+	const activeModel = requireProviderModelOverride(params.model);
+	const result = await describeVideoFile({
+		filePath: path.resolve(params.file),
+		cfg,
+		activeModel
+	});
+	if (!result.text) throw new Error(`No description returned for video: ${path.resolve(params.file)}`);
+	return {
+		ok: true,
+		capability: "video.describe",
+		transport: "local",
+		provider: result.provider,
+		model: result.model,
+		attempts: [],
+		outputs: [{
+			path: path.resolve(params.file),
+			text: result.text,
+			kind: "video.description"
+		}]
+	};
+}
+async function runTtsConvert(params) {
+	if (params.transport === "gateway") {
+		const gatewayConnection = buildGatewayConnectionDetailsWithResolvers({ config: loadConfig() });
+		const result = await callGateway({
+			method: "tts.convert",
+			params: {
+				text: params.text,
+				channel: params.channel,
+				provider: normalizeOptionalString(params.provider),
+				modelId: params.modelId,
+				voiceId: params.voiceId
+			},
+			timeoutMs: 12e4
+		});
+		let outputPath = result.audioPath;
+		if (params.output && result.audioPath) {
+			const gatewayHost = new URL(gatewayConnection.url).hostname;
+			if (!isLoopbackHost(gatewayHost)) throw new Error(`--output is not supported for remote gateway TTS yet (gateway target: ${gatewayConnection.url}).`);
+			const target = path.resolve(params.output);
+			await fs$1.mkdir(path.dirname(target), { recursive: true });
+			await fs$1.copyFile(result.audioPath, target);
+			outputPath = target;
+		}
+		return {
+			ok: true,
+			capability: "tts.convert",
+			transport: "gateway",
+			provider: result.provider,
+			attempts: [],
+			outputs: [{
+				path: outputPath,
+				format: result.outputFormat,
+				voiceCompatible: result.voiceCompatible
+			}]
+		};
+	}
+	const cfg = loadConfig();
+	const overrides = resolveExplicitTtsOverrides({
+		cfg,
+		provider: params.provider,
+		modelId: params.modelId,
+		voiceId: params.voiceId
+	});
+	const hasExplicitSelection = Boolean(overrides.provider || normalizeOptionalString(params.modelId) || normalizeOptionalString(params.voiceId));
+	const result = await textToSpeech({
+		text: params.text,
+		cfg,
+		channel: params.channel,
+		overrides,
+		disableFallback: hasExplicitSelection
+	});
+	if (!result.success || !result.audioPath) throw new Error(result.error ?? "TTS conversion failed");
+	let outputPath = result.audioPath;
+	if (params.output) {
+		const target = path.resolve(params.output);
+		await fs$1.mkdir(path.dirname(target), { recursive: true });
+		await fs$1.copyFile(result.audioPath, target);
+		outputPath = target;
+	}
+	return {
+		ok: true,
+		capability: "tts.convert",
+		transport: "local",
+		provider: result.provider,
+		attempts: result.attempts ?? [],
+		outputs: [{
+			path: outputPath,
+			format: result.outputFormat,
+			voiceCompatible: result.voiceCompatible
+		}]
+	};
+}
+async function runTtsProviders(transport) {
+	const cfg = loadConfig();
+	if (transport === "gateway") {
+		const payload = await callGateway({
+			method: "tts.providers",
+			timeoutMs: 3e4
+		});
+		return {
+			...payload,
+			providers: (payload.providers ?? []).map((provider) => {
+				const id = typeof provider.id === "string" ? provider.id : "";
+				return Object.assign({
+					available: true,
+					configured: typeof provider.configured === `boolean` ? provider.configured : providerHasGenericConfig({
+						cfg,
+						providerId: id
+					}),
+					selected: Boolean(id && payload.active === id)
+				}, provider);
+			})
+		};
+	}
+	const config = resolveTtsConfig(cfg);
+	const active = getTtsProvider(config, resolveTtsPrefsPath(config));
+	return {
+		providers: listSpeechProviders(cfg).map((provider) => ({
+			available: true,
+			configured: active === provider.id || providerHasGenericConfig({
+				cfg,
+				providerId: provider.id
+			}),
+			selected: active === provider.id,
+			id: provider.id,
+			name: provider.label,
+			models: [...provider.models ?? []],
+			voices: [...provider.voices ?? []]
+		})),
+		active
+	};
+}
+async function runTtsVoices(providerRaw) {
+	const cfg = loadConfig();
+	const config = resolveTtsConfig(cfg);
+	const prefsPath = resolveTtsPrefsPath(config);
+	return await listSpeechVoices({
+		provider: normalizeOptionalString(providerRaw) || getTtsProvider(config, prefsPath),
+		cfg,
+		config
+	});
+}
+async function runTtsStateMutation(params) {
+	if (params.transport === "gateway") return await callGateway({
+		method: params.capability === "tts.enable" ? "tts.enable" : params.capability === "tts.disable" ? "tts.disable" : "tts.setProvider",
+		params: params.provider ? { provider: params.provider } : void 0,
+		timeoutMs: 3e4
+	});
+	const cfg = loadConfig();
+	const prefsPath = resolveTtsPrefsPath(resolveTtsConfig(cfg));
+	if (params.capability === "tts.enable") {
+		setTtsEnabled(prefsPath, true);
+		return { enabled: true };
+	}
+	if (params.capability === "tts.disable") {
+		setTtsEnabled(prefsPath, false);
+		return { enabled: false };
+	}
+	if (!params.provider) throw new Error("--provider is required");
+	const provider = canonicalizeSpeechProviderId(params.provider, cfg);
+	if (!provider) throw new Error(`Unknown speech provider: ${params.provider}`);
+	setTtsProvider(prefsPath, provider);
+	return { provider };
+}
+async function runWebSearchCommand(params) {
+	const result = await runWebSearch({
+		config: loadConfig(),
+		providerId: params.provider,
+		args: {
+			query: params.query,
+			count: params.limit,
+			limit: params.limit
+		}
+	});
+	return {
+		ok: true,
+		capability: "web.search",
+		transport: "local",
+		provider: result.provider,
+		attempts: [],
+		outputs: [{ result: result.result }]
+	};
+}
+async function runWebFetchCommand(params) {
+	const resolved = resolveWebFetchDefinition({
+		config: loadConfig(),
+		providerId: params.provider
+	});
+	if (!resolved) throw new Error("web.fetch is disabled or no provider is available.");
+	const result = await resolved.definition.execute({
+		url: params.url,
+		format: params.format
+	});
+	return {
+		ok: true,
+		capability: "web.fetch",
+		transport: "local",
+		provider: resolved.provider.id,
+		attempts: [],
+		outputs: [{ result }]
+	};
+}
+async function runMemoryEmbeddingCreate(params) {
+	ensureMemoryEmbeddingProvidersRegistered();
+	const cfg = loadConfig();
+	const modelRef = resolveModelRefOverride(params.model);
+	const requestedProvider = normalizeOptionalString(params.provider) || modelRef.provider || "auto";
+	const result = await createEmbeddingProvider({
+		config: cfg,
+		agentDir: resolveAgentDir(cfg, resolveDefaultAgentId(cfg)),
+		provider: requestedProvider,
+		fallback: "none",
+		model: modelRef.model ?? ""
+	});
+	if (!result.provider) throw new Error(result.providerUnavailableReason ?? "No embedding provider available.");
+	const embeddings = await result.provider.embedBatch(params.texts);
+	return {
+		ok: true,
+		capability: "embedding.create",
+		transport: "local",
+		provider: result.provider.id,
+		model: result.provider.model,
+		attempts: result.fallbackFrom ? [{
+			provider: result.fallbackFrom,
+			outcome: "failed",
+			error: result.fallbackReason
+		}] : [],
+		outputs: embeddings.map((embedding, index) => ({
+			text: params.texts[index],
+			embedding,
+			dimensions: embedding.length
+		}))
+	};
+}
+function ensureMemoryEmbeddingProvidersRegistered() {
+	if (listMemoryEmbeddingProviders().length > 0) return;
+	registerBuiltInMemoryEmbeddingProviders({ registerMemoryEmbeddingProvider });
+}
+function registerCapabilityListAndInspect(capability) {
+	capability.command("list").description("List canonical capability ids and supported transports").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = CAPABILITY_METADATA.map((entry) => ({
+				id: entry.id,
+				transports: entry.transports,
+				description: entry.description
+			}));
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, providerSummaryText);
+		});
+	});
+	capability.command("inspect").description("Inspect one canonical capability id").requiredOption("--name <capability>", "Capability id").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const entry = findCapabilityMetadata(String(opts.name));
+			if (!entry) throw new Error(`Unknown capability: ${String(opts.name)}`);
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), entry, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+}
+function registerCapabilityCli(program) {
+	removeCommandByName(program, "infer");
+	removeCommandByName(program, "capability");
+	const capability = program.command("infer").alias("capability").description("Run provider-backed inference commands through a stable CLI surface").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/infer", "genesis.pixelzx.com/docs/cli/infer")}\n`);
+	registerCapabilityListAndInspect(capability);
+	const model = capability.command("model").description("Text inference and model catalog commands");
+	model.command("run").description("Run a one-shot model turn").requiredOption("--prompt <text>", "Prompt text").option("--model <provider/model>", "Model override").option("--local", "Force local execution", false).option("--gateway", "Force gateway execution", false).option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const transport = resolveTransport({
+				local: Boolean(opts.local),
+				gateway: Boolean(opts.gateway),
+				supported: ["local", "gateway"],
+				defaultTransport: "local"
+			});
+			const result = await runModelRun({
+				prompt: String(opts.prompt),
+				model: opts.model,
+				transport
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	model.command("list").description("List known models").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await loadModelCatalog({ config: loadConfig() });
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, providerSummaryText);
+		});
+	});
+	model.command("inspect").description("Inspect one model catalog entry").requiredOption("--model <provider/model>", "Model id").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const target = normalizeStringifiedOptionalString(opts.model) ?? "";
+			const catalog = await loadModelCatalog({ config: loadConfig() });
+			const entry = catalog.find((candidate) => `${candidate.provider}/${candidate.id}` === target) ?? catalog.find((candidate) => candidate.id === target);
+			if (!entry) throw new Error(`Model not found: ${target}`);
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), entry, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+	model.command("providers").description("List model providers from the catalog").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await buildModelProviders();
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, providerSummaryText);
+		});
+	});
+	const modelAuth = model.command("auth").description("Provider auth helpers");
+	modelAuth.command("login").description("Run provider auth login").requiredOption("--provider <id>", "Provider id").action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await modelsAuthLoginCommand({ provider: String(opts.provider) }, defaultRuntime);
+		});
+	});
+	modelAuth.command("logout").description("Remove saved auth profiles for one provider").requiredOption("--provider <id>", "Provider id").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runModelAuthLogout(String(opts.provider));
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+	modelAuth.command("status").description("Show configured auth state").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runModelAuthStatus();
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+	const image = capability.command("image").description("Image generation and description");
+	image.command("generate").description("Generate images").requiredOption("--prompt <text>", "Prompt text").option("--model <provider/model>", "Model override").option("--count <n>", "Number of images").option("--size <size>", "Size hint like 1024x1024").option("--aspect-ratio <ratio>", "Aspect ratio hint like 16:9").option("--resolution <value>", "Resolution hint: 1K, 2K, or 4K").option("--output <path>", "Output path").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runImageGenerate({
+				capability: "image.generate",
+				prompt: String(opts.prompt),
+				model: opts.model,
+				count: opts.count ? Number.parseInt(String(opts.count), 10) : void 0,
+				size: opts.size,
+				aspectRatio: opts.aspectRatio,
+				resolution: opts.resolution,
+				output: opts.output
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	image.command("edit").description("Edit images with one or more input files").requiredOption("--file <path>", "Input file", collectOption, []).requiredOption("--prompt <text>", "Prompt text").option("--model <provider/model>", "Model override").option("--output <path>", "Output path").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const files = Array.isArray(opts.file) ? opts.file : [String(opts.file)];
+			const result = await runImageGenerate({
+				capability: "image.edit",
+				prompt: String(opts.prompt),
+				model: opts.model,
+				file: files,
+				output: opts.output
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	image.command("describe").description("Describe one image file").requiredOption("--file <path>", "Image file").option("--model <provider/model>", "Model override").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runImageDescribe({
+				capability: "image.describe",
+				files: [String(opts.file)],
+				model: opts.model
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	image.command("describe-many").description("Describe multiple image files").requiredOption("--file <path>", "Image file", collectOption, []).option("--model <provider/model>", "Model override").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runImageDescribe({
+				capability: "image.describe-many",
+				files: opts.file,
+				model: opts.model
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	image.command("providers").description("List image generation providers").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const cfg = loadConfig();
+			const selectedProvider = resolveSelectedProviderFromModelRef(resolveAgentModelPrimaryValue(cfg.agents?.defaults?.imageGenerationModel));
+			const result = listRuntimeImageGenerationProviders({ config: cfg }).map((provider) => ({
+				available: true,
+				configured: selectedProvider === provider.id || providerHasGenericConfig({
+					cfg,
+					providerId: provider.id
+				}),
+				selected: selectedProvider === provider.id,
+				id: provider.id,
+				label: provider.label,
+				defaultModel: provider.defaultModel,
+				models: provider.models ?? [],
+				capabilities: provider.capabilities
+			}));
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, providerSummaryText);
+		});
+	});
+	const audio = capability.command("audio").description("Audio transcription");
+	audio.command("transcribe").description("Transcribe one audio file").requiredOption("--file <path>", "Audio file").option("--language <code>", "Language hint").option("--prompt <text>", "Prompt hint").option("--model <provider/model>", "Model override").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runAudioTranscribe({
+				file: String(opts.file),
+				language: opts.language,
+				model: opts.model,
+				prompt: opts.prompt
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	audio.command("providers").description("List audio transcription providers").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const cfg = loadConfig();
+			const providers = [...buildMediaUnderstandingRegistry(void 0, cfg).values()].filter((provider) => provider.capabilities?.includes("audio")).map((provider) => ({
+				available: true,
+				configured: providerHasGenericConfig({
+					cfg,
+					providerId: provider.id,
+					envVars: getProviderEnvVars(provider.id, {
+						config: cfg,
+						includeUntrustedWorkspacePlugins: false
+					})
+				}),
+				selected: false,
+				id: provider.id,
+				capabilities: provider.capabilities,
+				defaultModels: provider.defaultModels
+			}));
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), providers, providerSummaryText);
+		});
+	});
+	const tts = capability.command("tts").description("Text to speech");
+	tts.command("convert").description("Convert text to speech").requiredOption("--text <text>", "Input text").option("--channel <id>", "Channel hint").option("--voice <id>", "Voice hint").option("--model <provider/model>", "Model override").option("--output <path>", "Output path").option("--local", "Force local execution", false).option("--gateway", "Force gateway execution", false).option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const transport = resolveTransport({
+				local: Boolean(opts.local),
+				gateway: Boolean(opts.gateway),
+				supported: ["local", "gateway"],
+				defaultTransport: "local"
+			});
+			const modelRef = resolveModelRefOverride(opts.model);
+			if (opts.model && !modelRef.provider) throw new Error("TTS model overrides must use the form <provider/model>.");
+			const result = await runTtsConvert({
+				text: String(opts.text),
+				channel: opts.channel,
+				provider: modelRef.provider,
+				modelId: modelRef.provider ? modelRef.model : void 0,
+				voiceId: opts.voice,
+				output: opts.output,
+				transport
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	tts.command("voices").description("List voices for a TTS provider").option("--provider <id>", "Speech provider id").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const voices = await runTtsVoices(opts.provider);
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), voices, providerSummaryText);
+		});
+	});
+	tts.command("providers").description("List speech providers").option("--local", "Force local execution", false).option("--gateway", "Force gateway execution", false).option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runTtsProviders(resolveTransport({
+				local: Boolean(opts.local),
+				gateway: Boolean(opts.gateway),
+				supported: ["local", "gateway"],
+				defaultTransport: "local"
+			}));
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+	tts.command("status").description("Show TTS status").option("--gateway", "Force gateway execution", false).option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const transport = resolveTransport({
+				gateway: Boolean(opts.gateway),
+				supported: ["gateway"],
+				defaultTransport: "gateway"
+			});
+			const result = await callGateway({
+				method: "tts.status",
+				timeoutMs: 3e4
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), {
+				transport,
+				...result
+			}, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+	for (const [commandName, capabilityId] of [["enable", "tts.enable"], ["disable", "tts.disable"]]) tts.command(commandName).description(`${commandName === "enable" ? "Enable" : "Disable"} TTS`).option("--local", "Force local execution", false).option("--gateway", "Force gateway execution", false).option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runTtsStateMutation({
+				capability: capabilityId,
+				transport: resolveTransport({
+					local: Boolean(opts.local),
+					gateway: Boolean(opts.gateway),
+					supported: ["local", "gateway"],
+					defaultTransport: "gateway"
+				})
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+	tts.command("set-provider").description("Set the active TTS provider").requiredOption("--provider <id>", "Speech provider id").option("--local", "Force local execution", false).option("--gateway", "Force gateway execution", false).option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const transport = resolveTransport({
+				local: Boolean(opts.local),
+				gateway: Boolean(opts.gateway),
+				supported: ["local", "gateway"],
+				defaultTransport: "gateway"
+			});
+			const result = await runTtsStateMutation({
+				capability: "tts.set-provider",
+				provider: String(opts.provider),
+				transport
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+	const video = capability.command("video").description("Video generation and description");
+	video.command("generate").description("Generate video").requiredOption("--prompt <text>", "Prompt text").option("--model <provider/model>", "Model override").option("--output <path>", "Output path").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runVideoGenerate({
+				prompt: String(opts.prompt),
+				model: opts.model,
+				output: opts.output
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	video.command("describe").description("Describe one video file").requiredOption("--file <path>", "Video file").option("--model <provider/model>", "Model override").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runVideoDescribe({
+				file: String(opts.file),
+				model: opts.model
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	video.command("providers").description("List video generation and description providers").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const cfg = loadConfig();
+			const selectedGenerationProvider = resolveSelectedProviderFromModelRef(resolveAgentModelPrimaryValue(cfg.agents?.defaults?.videoGenerationModel));
+			const result = {
+				generation: listRuntimeVideoGenerationProviders({ config: cfg }).map((provider) => ({
+					available: true,
+					configured: selectedGenerationProvider === provider.id || providerHasGenericConfig({
+						cfg,
+						providerId: provider.id
+					}),
+					selected: selectedGenerationProvider === provider.id,
+					id: provider.id,
+					label: provider.label,
+					defaultModel: provider.defaultModel,
+					models: provider.models ?? [],
+					capabilities: provider.capabilities
+				})),
+				description: [...buildMediaUnderstandingRegistry(void 0, cfg).values()].filter((provider) => provider.capabilities?.includes("video")).map((provider) => ({
+					available: true,
+					configured: providerHasGenericConfig({
+						cfg,
+						providerId: provider.id
+					}),
+					selected: false,
+					id: provider.id,
+					capabilities: provider.capabilities,
+					defaultModels: provider.defaultModels
+				}))
+			};
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+	const web = capability.command("web").description("Web capabilities");
+	web.command("search").description("Run web search").requiredOption("--query <text>", "Search query").option("--provider <id>", "Provider id").option("--limit <n>", "Result limit").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runWebSearchCommand({
+				query: String(opts.query),
+				provider: opts.provider,
+				limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : void 0
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	web.command("fetch").description("Fetch one URL").requiredOption("--url <url>", "URL").option("--provider <id>", "Provider id").option("--format <format>", "Format hint").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runWebFetchCommand({
+				url: String(opts.url),
+				provider: opts.provider,
+				format: opts.format
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	web.command("providers").description("List web providers").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const cfg = loadConfig();
+			const selectedSearchProvider = typeof cfg.tools?.web?.search?.provider === "string" ? normalizeLowercaseStringOrEmpty(cfg.tools.web.search.provider) : "";
+			const selectedFetchProvider = typeof cfg.tools?.web?.fetch?.provider === "string" ? normalizeLowercaseStringOrEmpty(cfg.tools.web.fetch.provider) : "";
+			const result = {
+				search: listWebSearchProviders({ config: cfg }).map((provider) => ({
+					available: true,
+					configured: isWebSearchProviderConfigured({
+						provider,
+						config: cfg
+					}),
+					selected: provider.id === selectedSearchProvider,
+					id: provider.id,
+					envVars: provider.envVars
+				})),
+				fetch: listWebFetchProviders({ config: cfg }).map((provider) => ({
+					available: true,
+					configured: isWebFetchProviderConfigured({
+						provider,
+						config: cfg
+					}),
+					selected: provider.id === selectedFetchProvider,
+					id: provider.id,
+					envVars: provider.envVars
+				}))
+			};
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, (value) => JSON.stringify(value, null, 2));
+		});
+	});
+	const embedding = capability.command("embedding").description("Embedding providers");
+	embedding.command("create").description("Create embeddings").requiredOption("--text <text>", "Input text", collectOption, []).option("--provider <id>", "Provider id").option("--model <provider/model>", "Model override").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await runMemoryEmbeddingCreate({
+				texts: opts.text,
+				provider: opts.provider,
+				model: opts.model
+			});
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, formatEnvelopeForText);
+		});
+	});
+	embedding.command("providers").description("List embedding providers").option("--json", "Output JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			ensureMemoryEmbeddingProvidersRegistered();
+			const cfg = loadConfig();
+			const agentId = resolveDefaultAgentId(cfg);
+			const resolvedMemory = resolveMemorySearchConfig(cfg, agentId);
+			const selectedProvider = resolvedMemory?.provider && resolvedMemory.provider !== "auto" ? resolvedMemory.provider : void 0;
+			const autoSelectedProvider = resolvedMemory?.provider === "auto" ? (await createEmbeddingProvider({
+				config: cfg,
+				agentDir: resolveAgentDir(cfg, agentId),
+				provider: "auto",
+				fallback: "none",
+				model: resolvedMemory.model,
+				local: resolvedMemory.local,
+				remote: resolvedMemory.remote,
+				outputDimensionality: resolvedMemory.outputDimensionality
+			}).catch(() => ({ provider: null })))?.provider?.id : void 0;
+			const result = listMemoryEmbeddingProviders().map((provider) => ({
+				available: true,
+				configured: provider.id === selectedProvider || provider.id === autoSelectedProvider || providerHasGenericConfig({
+					cfg,
+					providerId: provider.id
+				}),
+				selected: provider.id === selectedProvider || provider.id === autoSelectedProvider,
+				id: provider.id,
+				defaultModel: provider.defaultModel,
+				transport: provider.transport,
+				autoSelectPriority: provider.autoSelectPriority
+			}));
+			emitJsonOrText(defaultRuntime, Boolean(opts.json), result, providerSummaryText);
+		});
+	});
+}
+//#endregion
+export { registerCapabilityCli };