@pixelzx/genesis 2026.5.5-2 → 2026.5.5-3

package/dist/onboard-helpers-BlPrFJHK.js

@@ -0,0 +1,204 @@
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { _ as shortenHomePath, f as resolveConfigDir, g as shortenHomeInString, v as sleep } from "./utils-DaGfogP-.js";
+import { o as resolveConfigPath } from "./paths-DmR9mjUX.js";
+import { n as VERSION } from "./version-BoqlEm3e.js";
+import { r as runCommandWithTimeout } from "./exec-CKo0c2Rj.js";
+import { n as resolveAgentModelPrimaryValue } from "./model-input-BkKFdMSQ.js";
+import { n as DEFAULT_AGENT_WORKSPACE_DIR, u as ensureAgentWorkspace } from "./workspace-DkmPqUjp.js";
+import { a as probeGateway } from "./probe-D-D_1oc4.js";
+import { r as normalizeControlUiBasePath } from "./control-ui-shared-BdBCVxcc.js";
+import "./control-ui-links-BvGEIgO7.js";
+import { l as resolveSessionTranscriptsDirForAgent } from "./paths-DD6L4IvS.js";
+import "./detect-binary-CABvUdOS.js";
+import { r as stylePromptTitle } from "./prompt-style-C0fEzBHW.js";
+import "./browser-open-Bha7Uu5E.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { inspect } from "node:util";
+import { cancel, isCancel } from "@clack/prompts";
+//#region src/commands/onboard-helpers.ts
+function guardCancel(value, runtime) {
+	if (isCancel(value)) {
+		cancel(stylePromptTitle("Setup cancelled.") ?? "Setup cancelled.");
+		runtime.exit(0);
+		throw new Error("unreachable");
+	}
+	return value;
+}
+function summarizeExistingConfig(config) {
+	const rows = [];
+	const defaults = config.agents?.defaults;
+	if (defaults?.workspace) rows.push(shortenHomeInString(`workspace: ${defaults.workspace}`));
+	if (defaults?.model) {
+		const model = resolveAgentModelPrimaryValue(defaults.model);
+		if (model) rows.push(shortenHomeInString(`model: ${model}`));
+	}
+	if (config.gateway?.mode) rows.push(shortenHomeInString(`gateway.mode: ${config.gateway.mode}`));
+	if (typeof config.gateway?.port === "number") rows.push(shortenHomeInString(`gateway.port: ${config.gateway.port}`));
+	if (config.gateway?.bind) rows.push(shortenHomeInString(`gateway.bind: ${config.gateway.bind}`));
+	if (config.gateway?.remote?.url) rows.push(shortenHomeInString(`gateway.remote.url: ${config.gateway.remote.url}`));
+	if (config.skills?.install?.nodeManager) rows.push(shortenHomeInString(`skills.nodeManager: ${config.skills.install.nodeManager}`));
+	return rows.length ? rows.join("\n") : "No key settings detected.";
+}
+function normalizeGatewayTokenInput(value) {
+	if (typeof value !== "string") return "";
+	const trimmed = value.trim();
+	if (trimmed === "undefined" || trimmed === "null") return "";
+	return trimmed;
+}
+function validateGatewayPasswordInput(value) {
+	if (typeof value !== "string") return "Required";
+	const trimmed = value.trim();
+	if (!trimmed) return "Required";
+	if (trimmed === "undefined" || trimmed === "null") return "Cannot be the literal string \"undefined\" or \"null\"";
+}
+function printWizardHeader(runtime) {
+	const header = [
+		"  ____                           _",
+		" / ___| ___ _ __   ___  ___ ___(_)___",
+		"| |  _ / _ \\ '_ \\ / _ \\/ __/ __| / __|",
+		"| |_| |  __/ | | |  __/\\__ \\__ \\ \\__ \\",
+		" \\____|\\___|_| |_|\\___||___/___/_|___/",
+		"",
+		"             GENESIS ONBOARDING"
+	].join("\n");
+	runtime.log(header);
+}
+function applyWizardMetadata(cfg, params) {
+	const commit = normalizeOptionalString(process.env.GIT_COMMIT) ?? normalizeOptionalString(process.env.GIT_SHA);
+	return {
+		...cfg,
+		wizard: {
+			...cfg.wizard,
+			lastRunAt: (/* @__PURE__ */ new Date()).toISOString(),
+			lastRunVersion: VERSION,
+			lastRunCommit: commit,
+			lastRunCommand: params.command,
+			lastRunMode: params.mode
+		}
+	};
+}
+function formatControlUiSshHint(params) {
+	const basePath = normalizeControlUiBasePath(params.basePath);
+	const uiPath = basePath ? `${basePath}/` : "/";
+	const localUrl = `http://localhost:${params.port}${uiPath}`;
+	const authedUrl = params.token ? `${localUrl}#token=${encodeURIComponent(params.token)}` : void 0;
+	const sshTarget = resolveSshTargetHint();
+	return [
+		"No GUI detected. Open from your computer:",
+		`ssh -N -L ${params.port}:127.0.0.1:${params.port} ${sshTarget}`,
+		"Then open:",
+		localUrl,
+		authedUrl,
+		"Docs:",
+		"https://docs.genesis.ai/gateway/remote",
+		"https://docs.genesis.ai/web/control-ui"
+	].filter(Boolean).join("\n");
+}
+function resolveSshTargetHint() {
+	return `${process.env.USER || process.env.LOGNAME || "user"}@${(process.env.SSH_CONNECTION?.trim().split(/\s+/))?.[2] ?? "<host>"}`;
+}
+async function ensureWorkspaceAndSessions(workspaceDir, runtime, options) {
+	const ws = await ensureAgentWorkspace({
+		dir: workspaceDir,
+		ensureBootstrapFiles: !options?.skipBootstrap
+	});
+	runtime.log(`Workspace OK: ${shortenHomePath(ws.dir)}`);
+	const sessionsDir = resolveSessionTranscriptsDirForAgent(options?.agentId);
+	await fs.mkdir(sessionsDir, { recursive: true });
+	runtime.log(`Sessions OK: ${shortenHomePath(sessionsDir)}`);
+}
+function resolveNodeManagerOptions() {
+	return [
+		{
+			value: "npm",
+			label: "npm"
+		},
+		{
+			value: "pnpm",
+			label: "pnpm"
+		},
+		{
+			value: "bun",
+			label: "bun"
+		}
+	];
+}
+async function moveToTrash(pathname, runtime) {
+	if (!pathname) return;
+	try {
+		await fs.access(pathname);
+	} catch {
+		return;
+	}
+	try {
+		await runCommandWithTimeout(["trash", pathname], { timeoutMs: 5e3 });
+		runtime.log(`Moved to Trash: ${shortenHomePath(pathname)}`);
+	} catch {
+		runtime.log(`Failed to move to Trash (manual delete): ${shortenHomePath(pathname)}`);
+	}
+}
+async function handleReset(scope, workspaceDir, runtime) {
+	await moveToTrash(resolveConfigPath(), runtime);
+	if (scope === "config") return;
+	await moveToTrash(path.join(resolveConfigDir(), "credentials"), runtime);
+	await moveToTrash(resolveSessionTranscriptsDirForAgent(), runtime);
+	if (scope === "full") await moveToTrash(workspaceDir, runtime);
+}
+async function probeGatewayReachable(params) {
+	const url = params.url.trim();
+	const timeoutMs = params.timeoutMs ?? 1500;
+	try {
+		const probe = await probeGateway({
+			url,
+			timeoutMs,
+			auth: {
+				token: params.token,
+				password: params.password
+			},
+			detailLevel: "none"
+		});
+		return probe.ok ? { ok: true } : {
+			ok: false,
+			detail: probe.error ?? void 0
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			detail: summarizeError(err)
+		};
+	}
+}
+async function waitForGatewayReachable(params) {
+	const deadlineMs = params.deadlineMs ?? 15e3;
+	const pollMs = params.pollMs ?? 400;
+	const probeTimeoutMs = params.probeTimeoutMs ?? 1500;
+	const startedAt = Date.now();
+	let lastDetail;
+	while (Date.now() - startedAt < deadlineMs) {
+		const probe = await probeGatewayReachable({
+			url: params.url,
+			token: params.token,
+			password: params.password,
+			timeoutMs: probeTimeoutMs
+		});
+		if (probe.ok) return probe;
+		lastDetail = probe.detail;
+		await sleep(pollMs);
+	}
+	return {
+		ok: false,
+		detail: lastDetail
+	};
+}
+function summarizeError(err) {
+	let raw = "unknown error";
+	if (err instanceof Error) raw = err.message || raw;
+	else if (typeof err === "string") raw = err || raw;
+	else if (err !== void 0) raw = inspect(err, { depth: 2 });
+	const line = raw.split("\n").map((s) => s.trim()).find(Boolean) ?? raw;
+	return line.length > 120 ? `${line.slice(0, 119)}…` : line;
+}
+const DEFAULT_WORKSPACE = DEFAULT_AGENT_WORKSPACE_DIR;
+//#endregion
+export { guardCancel as a, normalizeGatewayTokenInput as c, resolveNodeManagerOptions as d, summarizeExistingConfig as f, formatControlUiSshHint as i, printWizardHeader as l, waitForGatewayReachable as m, applyWizardMetadata as n, handleReset as o, validateGatewayPasswordInput as p, ensureWorkspaceAndSessions as r, moveToTrash as s, DEFAULT_WORKSPACE as t, probeGatewayReachable as u };

package/dist/onboard-helpers-kL8mgUkl.js

@@ -0,0 +1,6 @@
+import { t as randomToken } from "./random-token-B_Oj5J92.js";
+import "./control-ui-links-BvGEIgO7.js";
+import "./detect-binary-CABvUdOS.js";
+import { n as openUrl } from "./browser-open-Bha7Uu5E.js";
+import { f as summarizeExistingConfig, l as printWizardHeader, n as applyWizardMetadata, o as handleReset, r as ensureWorkspaceAndSessions, t as DEFAULT_WORKSPACE, u as probeGatewayReachable } from "./onboard-helpers-BlPrFJHK.js";
+export { DEFAULT_WORKSPACE, applyWizardMetadata, ensureWorkspaceAndSessions, handleReset, openUrl, printWizardHeader, probeGatewayReachable, randomToken, summarizeExistingConfig };

package/dist/onboard-remote-ByHuQd1m.js

@@ -0,0 +1,193 @@
+import { c as isSecureWebSocketUrl } from "./net-AycWGi8-.js";
+import { t as resolveSecretInputModeForEnvSelection } from "./provider-auth-mode-d-pK4dGf.js";
+import { n as promptSecretRefForSetup } from "./provider-auth-ref-BZqaa5c2.js";
+import { t as detectBinary } from "./detect-binary-CABvUdOS.js";
+import { i as resolveWideAreaDiscoveryDomain } from "./widearea-dns-DpfsHW86.js";
+import { t as discoverGatewayBeacons } from "./bonjour-discovery-BHGMSuOD.js";
+import { n as buildGatewayDiscoveryTarget, t as buildGatewayDiscoveryLabel } from "./gateway-discovery-targets-B6leyUuQ.js";
+import "./onboard-helpers-BlPrFJHK.js";
+//#region src/commands/onboard-remote.ts
+const DEFAULT_GATEWAY_URL = "ws://127.0.0.1:18789";
+function buildLabel(beacon) {
+	return buildGatewayDiscoveryLabel(beacon);
+}
+function ensureWsUrl(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return DEFAULT_GATEWAY_URL;
+	return trimmed;
+}
+function validateGatewayWebSocketUrl(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("ws://") && !trimmed.startsWith("wss://")) return "URL must start with ws:// or wss://";
+	if (!isSecureWebSocketUrl(trimmed, { allowPrivateWs: process.env.GENESIS_ALLOW_INSECURE_PRIVATE_WS === "1" })) return "Use wss:// for remote hosts, or ws://127.0.0.1/localhost via SSH tunnel. Break-glass: GENESIS_ALLOW_INSECURE_PRIVATE_WS=1 for trusted private networks.";
+}
+async function promptRemoteGatewayConfig(cfg, prompter, options) {
+	let selectedBeacon = null;
+	let suggestedUrl = cfg.gateway?.remote?.url ?? DEFAULT_GATEWAY_URL;
+	let discoveryTlsFingerprint;
+	let trustedDiscoveryUrl;
+	const hasBonjourTool = await detectBinary("dns-sd") || await detectBinary("avahi-browse");
+	const wantsDiscover = hasBonjourTool ? await prompter.confirm({
+		message: "Discover gateway on LAN (Bonjour)?",
+		initialValue: true
+	}) : false;
+	if (!hasBonjourTool) await prompter.note(["Bonjour discovery requires dns-sd (macOS) or avahi-browse (Linux).", "Docs: https://docs.genesis.ai/gateway/discovery"].join("\n"), "Discovery");
+	if (wantsDiscover) {
+		const wideAreaDomain = resolveWideAreaDiscoveryDomain({ configDomain: cfg.discovery?.wideArea?.domain });
+		const spin = prompter.progress("Searching for gateways…");
+		const beacons = await discoverGatewayBeacons({
+			timeoutMs: 2e3,
+			wideAreaDomain
+		});
+		spin.stop(beacons.length > 0 ? `Found ${beacons.length} gateway(s)` : "No gateways found");
+		if (beacons.length > 0) {
+			const selection = await prompter.select({
+				message: "Select gateway",
+				options: [...beacons.map((beacon, index) => ({
+					value: String(index),
+					label: buildLabel(beacon)
+				})), {
+					value: "manual",
+					label: "Enter URL manually"
+				}]
+			});
+			if (selection !== "manual") {
+				const idx = Number.parseInt(selection, 10);
+				selectedBeacon = Number.isFinite(idx) ? beacons[idx] ?? null : null;
+			}
+		}
+	}
+	if (selectedBeacon) {
+		const target = buildGatewayDiscoveryTarget(selectedBeacon);
+		if (target.endpoint) {
+			const { host, port } = target.endpoint;
+			if (await prompter.select({
+				message: "Connection method",
+				options: [{
+					value: "direct",
+					label: `Direct gateway WS (${host}:${port})`
+				}, {
+					value: "ssh",
+					label: "SSH tunnel (loopback)"
+				}]
+			}) === "direct") {
+				suggestedUrl = `wss://${host}:${port}`;
+				const fingerprint = target.endpoint.gatewayTlsFingerprintSha256;
+				if (await prompter.confirm({
+					message: `Trust this gateway? Host: ${host}:${port} TLS fingerprint: ${fingerprint ?? "not advertised (connection will not be pinned)"}`,
+					initialValue: false
+				})) {
+					discoveryTlsFingerprint = fingerprint;
+					trustedDiscoveryUrl = suggestedUrl;
+					await prompter.note([
+						"Direct remote access defaults to TLS.",
+						`Using: ${suggestedUrl}`,
+						...fingerprint ? [`TLS pin: ${fingerprint}`] : [],
+						"If your gateway is loopback-only, choose SSH tunnel and keep ws://127.0.0.1:18789."
+					].join("\n"), "Direct remote");
+				} else suggestedUrl = DEFAULT_GATEWAY_URL;
+			} else {
+				suggestedUrl = DEFAULT_GATEWAY_URL;
+				await prompter.note([
+					"Start a tunnel before using the CLI:",
+					`ssh -N -L 18789:127.0.0.1:18789 <user>@${host}${target.sshPort ? ` -p ${target.sshPort}` : ""}`,
+					"Docs: https://docs.genesis.ai/gateway/remote"
+				].join("\n"), "SSH tunnel");
+			}
+		}
+	}
+	const url = ensureWsUrl(await prompter.text({
+		message: "Gateway WebSocket URL",
+		initialValue: suggestedUrl,
+		validate: (value) => validateGatewayWebSocketUrl(value)
+	}));
+	const pinnedDiscoveryFingerprint = discoveryTlsFingerprint && url === trustedDiscoveryUrl ? discoveryTlsFingerprint : void 0;
+	const authChoice = await prompter.select({
+		message: "Gateway auth",
+		options: [
+			{
+				value: "token",
+				label: "Token (recommended)"
+			},
+			{
+				value: "password",
+				label: "Password"
+			},
+			{
+				value: "off",
+				label: "No auth"
+			}
+		]
+	});
+	let token = cfg.gateway?.remote?.token;
+	let password = cfg.gateway?.remote?.password;
+	if (authChoice === "token") {
+		if (await resolveSecretInputModeForEnvSelection({
+			prompter,
+			explicitMode: options?.secretInputMode,
+			copy: {
+				modeMessage: "How do you want to provide this gateway token?",
+				plaintextLabel: "Enter token now",
+				plaintextHint: "Stores the token directly in Genesis config"
+			}
+		}) === "ref") token = (await promptSecretRefForSetup({
+			provider: "gateway-remote-token",
+			config: cfg,
+			prompter,
+			preferredEnvVar: "GENESIS_GATEWAY_TOKEN",
+			copy: {
+				sourceMessage: "Where is this gateway token stored?",
+				envVarPlaceholder: "GENESIS_GATEWAY_TOKEN"
+			}
+		})).ref;
+		else token = (await prompter.text({
+			message: "Gateway token",
+			initialValue: typeof token === "string" ? token : void 0,
+			validate: (value) => value?.trim() ? void 0 : "Required"
+		})).trim();
+		password = void 0;
+	} else if (authChoice === "password") {
+		if (await resolveSecretInputModeForEnvSelection({
+			prompter,
+			explicitMode: options?.secretInputMode,
+			copy: {
+				modeMessage: "How do you want to provide this gateway password?",
+				plaintextLabel: "Enter password now",
+				plaintextHint: "Stores the password directly in Genesis config"
+			}
+		}) === "ref") password = (await promptSecretRefForSetup({
+			provider: "gateway-remote-password",
+			config: cfg,
+			prompter,
+			preferredEnvVar: "GENESIS_GATEWAY_PASSWORD",
+			copy: {
+				sourceMessage: "Where is this gateway password stored?",
+				envVarPlaceholder: "GENESIS_GATEWAY_PASSWORD"
+			}
+		})).ref;
+		else password = (await prompter.text({
+			message: "Gateway password",
+			initialValue: typeof password === "string" ? password : void 0,
+			validate: (value) => value?.trim() ? void 0 : "Required"
+		})).trim();
+		token = void 0;
+	} else {
+		token = void 0;
+		password = void 0;
+	}
+	return {
+		...cfg,
+		gateway: {
+			...cfg.gateway,
+			mode: "remote",
+			remote: {
+				url,
+				...token !== void 0 ? { token } : {},
+				...password !== void 0 ? { password } : {},
+				...pinnedDiscoveryFingerprint ? { tlsFingerprint: pinnedDiscoveryFingerprint } : {}
+			}
+		}
+	};
+}
+//#endregion
+export { promptRemoteGatewayConfig as t };

package/dist/onboard-remote-CRPXcrWy.js

@@ -0,0 +1,2 @@
+import { t as promptRemoteGatewayConfig } from "./onboard-remote-ByHuQd1m.js";
+export { promptRemoteGatewayConfig };

package/dist/onboard-skills-ChtyNRCd.js

@@ -0,0 +1,2 @@
+import { t as setupSkills } from "./onboard-skills-DROlYXya.js";
+export { setupSkills };

package/dist/onboard-skills-DROlYXya.js

@@ -0,0 +1,134 @@
+import { t as formatCliCommand } from "./command-format-DAeUlu7u.js";
+import { n as normalizeSecretInput } from "./normalize-secret-input-CNeH9Ebc.js";
+import { t as detectBinary } from "./detect-binary-CABvUdOS.js";
+import { t as buildWorkspaceSkillStatus } from "./skills-status-7DS_HH5S.js";
+import { d as resolveNodeManagerOptions } from "./onboard-helpers-BlPrFJHK.js";
+import { t as installSkill } from "./skills-install-t0n3WX38.js";
+//#region src/commands/onboard-skills.ts
+function summarizeInstallFailure(message) {
+	const cleaned = message.replace(/^Install failed(?:\s*\([^)]*\))?\s*:?\s*/i, "").trim();
+	if (!cleaned) return;
+	const maxLen = 140;
+	return cleaned.length > maxLen ? `${cleaned.slice(0, maxLen - 1)}…` : cleaned;
+}
+function formatSkillHint(skill) {
+	const desc = skill.description?.trim();
+	const installLabel = skill.install[0]?.label?.trim();
+	const combined = desc && installLabel ? `${desc} — ${installLabel}` : desc || installLabel;
+	if (!combined) return "install";
+	const maxLen = 90;
+	return combined.length > maxLen ? `${combined.slice(0, maxLen - 1)}…` : combined;
+}
+function upsertSkillEntry(cfg, skillKey, patch) {
+	const entries = { ...cfg.skills?.entries };
+	entries[skillKey] = {
+		...entries[skillKey] ?? {},
+		...patch
+	};
+	return {
+		...cfg,
+		skills: {
+			...cfg.skills,
+			entries
+		}
+	};
+}
+async function setupSkills(cfg, workspaceDir, runtime, prompter) {
+	const report = buildWorkspaceSkillStatus(workspaceDir, { config: cfg });
+	const eligible = report.skills.filter((s) => s.eligible);
+	const unsupportedOs = report.skills.filter((s) => !s.disabled && !s.blockedByAllowlist && s.missing.os.length > 0);
+	const missing = report.skills.filter((s) => !s.eligible && !s.disabled && !s.blockedByAllowlist && s.missing.os.length === 0);
+	const blocked = report.skills.filter((s) => s.blockedByAllowlist);
+	await prompter.note([
+		`Eligible: ${eligible.length}`,
+		`Missing requirements: ${missing.length}`,
+		`Unsupported on this OS: ${unsupportedOs.length}`,
+		`Blocked by allowlist: ${blocked.length}`
+	].join("\n"), "Skills status");
+	if (!await prompter.confirm({
+		message: "Configure skills now? (recommended)",
+		initialValue: true
+	})) return cfg;
+	const installable = missing.filter((skill) => skill.install.length > 0 && skill.missing.bins.length > 0);
+	let next = cfg;
+	if (installable.length > 0) {
+		const selected = (await prompter.multiselect({
+			message: "Install missing skill dependencies",
+			options: [{
+				value: "__skip__",
+				label: "Skip for now",
+				hint: "Continue without installing dependencies"
+			}, ...installable.map((skill) => ({
+				value: skill.name,
+				label: `${skill.emoji ?? "🧩"} ${skill.name}`,
+				hint: formatSkillHint(skill)
+			}))]
+		})).filter((name) => name !== "__skip__");
+		const selectedSkills = selected.map((name) => installable.find((s) => s.name === name)).filter((item) => Boolean(item));
+		if (process.platform !== "win32" && selectedSkills.some((skill) => skill.install.some((option) => option.kind === "brew")) && !await detectBinary("brew")) {
+			await prompter.note(["Many skill dependencies are shipped via Homebrew.", "Without brew, you'll need to build from source or download releases manually."].join("\n"), "Homebrew recommended");
+			if (await prompter.confirm({
+				message: "Show Homebrew install command?",
+				initialValue: true
+			})) await prompter.note(["Run:", "/bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\""].join("\n"), "Homebrew install");
+		}
+		if (selectedSkills.some((skill) => skill.install.some((option) => option.kind === "node"))) {
+			const nodeManager = await prompter.select({
+				message: "Preferred node manager for skill installs",
+				options: resolveNodeManagerOptions()
+			});
+			next = {
+				...next,
+				skills: {
+					...next.skills,
+					install: {
+						...next.skills?.install,
+						nodeManager
+					}
+				}
+			};
+		}
+		for (const name of selected) {
+			const target = installable.find((s) => s.name === name);
+			if (!target || target.install.length === 0) continue;
+			const installId = target.install[0]?.id;
+			if (!installId) continue;
+			const spin = prompter.progress(`Installing ${name}…`);
+			const result = await installSkill({
+				workspaceDir,
+				skillName: target.name,
+				installId,
+				config: next
+			});
+			const warnings = result.warnings ?? [];
+			if (result.ok) {
+				spin.stop(warnings.length > 0 ? `Installed ${name} (with warnings)` : `Installed ${name}`);
+				for (const warning of warnings) runtime.log(warning);
+				continue;
+			}
+			const code = result.code == null ? "" : ` (exit ${result.code})`;
+			const detail = summarizeInstallFailure(result.message);
+			spin.stop(`Install failed: ${name}${code}${detail ? ` — ${detail}` : ""}`);
+			for (const warning of warnings) runtime.log(warning);
+			if (result.stderr) runtime.log(result.stderr.trim());
+			else if (result.stdout) runtime.log(result.stdout.trim());
+			runtime.log(`Tip: run \`${formatCliCommand("genesis doctor")}\` to review skills + requirements.`);
+			runtime.log("Docs: https://docs.genesis.ai/skills");
+		}
+	}
+	for (const skill of missing) {
+		if (!skill.primaryEnv || skill.missing.env.length === 0) continue;
+		if (!await prompter.confirm({
+			message: `Set ${skill.primaryEnv} for ${skill.name}?`,
+			initialValue: false
+		})) continue;
+		const apiKey = await prompter.text({
+			message: `Enter ${skill.primaryEnv}`,
+			validate: (value) => value?.trim() ? void 0 : "Required"
+		});
+		next = upsertSkillEntry(next, skill.skillKey, { apiKey: normalizeSecretInput(apiKey) });
+	}
+	return next;
+}
+//#endregion
+export { setupSkills as t };