hyperclaw 4.0.2 → 5.0.0

package/dist/onboard-BXNXCQp4.js

@@ -0,0 +1,4070 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const require_env_resolve = require('./env-resolve-CmGWhWXJ.js');
+const require_daemon = require('./daemon-Bg4GtCmc.js');
+const require_theme = require('./theme-DcxwcUgZ.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const inquirer = require_chunk.__toESM(require("inquirer"));
+const ora = require_chunk.__toESM(require("ora"));
+const boxen = require_chunk.__toESM(require("boxen"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+const crypto = require_chunk.__toESM(require("crypto"));
+const child_process = require_chunk.__toESM(require("child_process"));
+const util = require_chunk.__toESM(require("util"));
+const ws = require_chunk.__toESM(require("ws"));
+const https = require_chunk.__toESM(require("https"));
+const gradient_string = require_chunk.__toESM(require("gradient-string"));
+const figlet = require_chunk.__toESM(require("figlet"));
+
+//#region src/cli/config.ts
+require_paths$1.init_paths();
+require_env_resolve.init_env_resolve();
+const getHC_DIR = () => require_paths.getHyperClawDir();
+const getCFG_FILE = () => require_paths.getConfigPath();
+var ConfigStore = class {
+	async load() {
+		try {
+			const cfg = await fs_extra.default.readJson(getCFG_FILE());
+			if (cfg.channelConfigs) for (const [chId, ch] of Object.entries(cfg.channelConfigs)) {
+				const tok = require_env_resolve.resolveChannelToken(chId, ch?.token || ch?.botToken);
+				if (tok && !ch?.token) ch.token = tok;
+				if (tok && !ch?.botToken) ch.botToken = tok;
+			}
+			return cfg;
+		} catch {
+			return {};
+		}
+	}
+	async save(cfg) {
+		await fs_extra.default.ensureDir(getHC_DIR());
+		await fs_extra.default.writeJson(getCFG_FILE(), cfg, { spaces: 2 });
+		await fs_extra.default.chmod(getCFG_FILE(), 384);
+	}
+	async patch(patch) {
+		const current = await this.load();
+		await this.save(deepMerge(current, patch));
+	}
+	async setProviderKey(providerId, apiKey) {
+		const cfg = await this.load();
+		await this.patch({ provider: {
+			...cfg.provider,
+			providerId,
+			apiKey
+		} });
+		console.log(chalk.default.green(`  ✅ API key saved for ${providerId}`));
+	}
+	async setModel(modelId) {
+		const cfg = await this.load();
+		await this.patch({ provider: {
+			...cfg.provider,
+			modelId
+		} });
+		console.log(chalk.default.green(`  ✅ Model: ${modelId}`));
+	}
+	async setServiceApiKey(serviceId, apiKey) {
+		const cfg = await this.load();
+		const apiKeys = {
+			...cfg.skills?.apiKeys || {},
+			[serviceId]: apiKey
+		};
+		await this.patch({ skills: {
+			...cfg.skills,
+			installed: cfg.skills?.installed || [],
+			apiKeys
+		} });
+		console.log(chalk.default.green(`  ✅ Service API key saved for ${serviceId}`));
+	}
+	async enableChannel(channelId, channelConfig) {
+		const cfg = await this.load();
+		const channels = cfg.gateway?.enabledChannels || [];
+		if (!channels.includes(channelId)) channels.push(channelId);
+		const patch = { gateway: {
+			...cfg.gateway,
+			enabledChannels: channels
+		} };
+		if (channelConfig) patch.channelConfigs = {
+			...cfg.channelConfigs,
+			[channelId]: channelConfig
+		};
+		await this.patch(patch);
+		console.log(chalk.default.green(`  ✅ Channel enabled: ${channelId}`));
+	}
+	async disableChannel(channelId) {
+		const cfg = await this.load();
+		const channels = (cfg.gateway?.enabledChannels || []).filter((c) => c !== channelId);
+		await this.patch({ gateway: {
+			...cfg.gateway,
+			enabledChannels: channels
+		} });
+		console.log(chalk.default.green(`  ✅ Channel disabled: ${channelId}`));
+	}
+	async setGatewayPort(port) {
+		const cfg = await this.load();
+		await this.patch({ gateway: {
+			...cfg.gateway,
+			port
+		} });
+	}
+	async setGatewayBind(bind) {
+		const cfg = await this.load();
+		await this.patch({ gateway: {
+			...cfg.gateway,
+			bind
+		} });
+	}
+	async generateToken() {
+		const token = require("crypto").randomBytes(32).toString("base64url");
+		const cfg = await this.load();
+		await this.patch({ gateway: {
+			...cfg.gateway,
+			authToken: token
+		} });
+		return token;
+	}
+	async show(scrub = true) {
+		const cfg = await this.load();
+		const display = scrub ? scrubSecrets(cfg) : cfg;
+		console.log(chalk.default.bold.cyan("\n  🦅 HYPERCLAW CONFIGURATION\n"));
+		printSection("Provider", display.provider);
+		printSection("Gateway", display.gateway);
+		printSection("Identity", display.identity);
+		printSection("PC Access", display.pcAccess);
+		if (display.channelConfigs && Object.keys(display.channelConfigs).length > 0) {
+			console.log(chalk.default.bold.white("  Channel Configs:"));
+			for (const [ch, v] of Object.entries(display.channelConfigs)) {
+				const scrubbed = scrubChannelConfig(v);
+				console.log(`    ${chalk.default.cyan(ch)}: ${JSON.stringify(scrubbed).slice(0, 80)}`);
+			}
+			console.log();
+		}
+		if (display.skills?.installed?.length) {
+			console.log(chalk.default.bold.white("  Skills:"));
+			display.skills.installed.forEach((s) => console.log(`    • ${s}`));
+			console.log();
+		}
+		console.log(chalk.default.gray(`  Config file: ${getCFG_FILE()}`));
+		console.log();
+	}
+};
+function deepMerge(base, patch) {
+	const result = { ...base };
+	for (const key of Object.keys(patch || {})) if (patch[key] !== null && typeof patch[key] === "object" && !Array.isArray(patch[key])) result[key] = deepMerge(base[key] || {}, patch[key]);
+	else result[key] = patch[key];
+	return result;
+}
+function scrubSecrets(cfg) {
+	const s = JSON.parse(JSON.stringify(cfg));
+	if (s.provider?.apiKey) s.provider.apiKey = "●●●●●●●●";
+	if (s.gateway?.authToken) s.gateway.authToken = s.gateway.authToken ? "●●●●●●●●" : "(none)";
+	if (s.skills?.apiKeys) {
+		const keys = Object.keys(s.skills.apiKeys);
+		s.skills.apiKeys = Object.fromEntries(keys.map((k) => [k, "●●●●●●●●"]));
+	}
+	return s;
+}
+function scrubChannelConfig(ch) {
+	const s = { ...ch };
+	const secretFields = [
+		"token",
+		"accessToken",
+		"apiKey",
+		"appSecret",
+		"appPassword",
+		"signingSecret",
+		"channelSecret",
+		"secretKey",
+		"password",
+		"verifyToken"
+	];
+	for (const f of secretFields) if (s[f]) s[f] = "●●●●●●●●";
+	return s;
+}
+function printSection(label, data) {
+	if (!data || Object.keys(data).length === 0) return;
+	console.log(chalk.default.bold.white(`  ${label}:`));
+	for (const [k, v] of Object.entries(data)) if (Array.isArray(v)) console.log(`    ${chalk.default.gray(k)}: ${v.join(", ") || "(none)"}`);
+	else console.log(`    ${chalk.default.gray(k)}: ${v}`);
+	console.log();
+}
+
+//#endregion
+//#region src/cli/gateway.ts
+const execAsync = (0, util.promisify)(child_process.exec);
+const HC_DIR$1 = path.default.join(os.default.homedir(), ".hyperclaw");
+var GatewayManager = class {
+	async isRunning(port = 18789) {
+		return this.detect(port);
+	}
+	async detectRuntime() {
+		for (const r of [
+			"bun",
+			"deno",
+			"node"
+		]) try {
+			await execAsync(`which ${r}`);
+			return r;
+		} catch {}
+		return "node";
+	}
+	exposureLabel(e) {
+		const m = {
+			off: "Off",
+			serve: "Serve (Tailscale)",
+			funnel: "Funnel (public)"
+		};
+		return m[e] || e;
+	}
+	async detect(port = 18789) {
+		return new Promise((resolve) => {
+			try {
+				const ws$1 = new ws.WebSocket(`ws://127.0.0.1:${port}`);
+				const t = setTimeout(() => {
+					ws$1.terminate();
+					resolve(false);
+				}, 1500);
+				ws$1.on("open", () => {
+					clearTimeout(t);
+					ws$1.close();
+					resolve(true);
+				});
+				ws$1.on("error", () => {
+					clearTimeout(t);
+					resolve(false);
+				});
+			} catch {
+				resolve(false);
+			}
+		});
+	}
+	async showStatus(cfg) {
+		const running = await this.detect(cfg.port);
+		const bindLabel = {
+			"127.0.0.1": "loopback (localhost only)",
+			"0.0.0.0": "all interfaces (LAN)",
+			"tailscale": "Tailscale VPN only"
+		}[cfg.bind] || cfg.bind;
+		console.log(chalk.default.bold.cyan("\n  💻 GATEWAY\n"));
+		console.log(`  ${running ? chalk.default.green("● Running") : chalk.default.gray("○ Stopped")}  ws://127.0.0.1:${cfg.port}`);
+		console.log(`  Bind:     ${bindLabel}`);
+		console.log(`  Runtime:  ${cfg.runtime}${cfg.runtime === "node" ? chalk.default.gray(" (recommended)") : ""}`);
+		if (cfg.tailscaleExposure !== "off") console.log(`  Tailscale: ${chalk.default.yellow(cfg.tailscaleExposure)}`);
+		console.log(`  Token:    ${cfg.authToken ? chalk.default.green("set") : chalk.default.yellow("none (open)")}`);
+		console.log(`  Channels: ${cfg.enabledChannels.join(", ") || chalk.default.gray("none")}`);
+		console.log();
+	}
+	async applyTailscaleExposure(mode, port) {
+		try {
+			if (mode === "serve") await execAsync(`tailscale serve https / http://localhost:${port}`);
+			else await execAsync(`tailscale funnel ${port}`);
+			console.log(chalk.default.green(`  ✅ Tailscale ${mode} enabled`));
+		} catch (e) {
+			console.log(chalk.default.yellow(`  ⚠  Tailscale: ${e.message.slice(0, 60)}`));
+		}
+	}
+	generateToken() {
+		return require("crypto").randomBytes(32).toString("base64url");
+	}
+	async resolveBindAddress(bind) {
+		if (["127.0.0.1", "0.0.0.0"].includes(bind)) return bind;
+		if (bind === "tailscale") try {
+			const { stdout } = await execAsync("tailscale ip -4 2>/dev/null");
+			return stdout.trim();
+		} catch {
+			return "127.0.0.1";
+		}
+		return bind;
+	}
+	async installService(cfg) {
+		const platform = os.default.platform();
+		if (platform === "linux") await this.installSystemd(cfg);
+		else if (platform === "darwin") await this.installLaunchAgent(cfg);
+		else console.log(chalk.default.yellow("  Windows: Use NSSM or Task Scheduler"));
+	}
+	async installSystemd(cfg) {
+		const binary = process.execPath;
+		const content = `[Unit]
+Description=HyperClaw Gateway
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${binary} ${path.default.join(__dirname, "../../dist/cli/run-main.js")} gateway start
+Restart=on-failure
+RestartSec=5
+Environment=PORT=${cfg.port}
+
+[Install]
+WantedBy=default.target
+`;
+		const serviceDir = path.default.join(os.default.homedir(), ".config/systemd/user");
+		const serviceFile = path.default.join(serviceDir, "hyperclaw.service");
+		try {
+			await fs_extra.default.ensureDir(serviceDir);
+			await fs_extra.default.writeFile(serviceFile, content);
+			await execAsync("systemctl --user daemon-reload");
+			await execAsync("systemctl --user enable hyperclaw");
+			await execAsync(`loginctl enable-linger ${os.default.userInfo().username}`).catch(() => {});
+			console.log(chalk.default.green("  ✅ systemd service installed (lingering enabled)"));
+		} catch (e) {
+			console.log(chalk.default.gray(`  Service file: ${serviceFile}`));
+		}
+	}
+	async installLaunchAgent(cfg) {
+		const binary = process.execPath;
+		const plistDir = path.default.join(os.default.homedir(), "Library/LaunchAgents");
+		const plistPath = path.default.join(plistDir, "ai.hyperclaw.gateway.plist");
+		const content = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>ai.hyperclaw.gateway</string>
+  <key>ProgramArguments</key><array>
+    <string>${binary}</string>
+    <string>${path.default.join(__dirname, "../../dist/cli/run-main.js")}</string>
+    <string>gateway</string><string>start</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${HC_DIR$1}/gateway.log</string>
+  <key>StandardErrorPath</key><string>${HC_DIR$1}/gateway.err</string>
+</dict></plist>`;
+		await fs_extra.default.ensureDir(plistDir);
+		await fs_extra.default.writeFile(plistPath, content);
+		try {
+			await execAsync(`launchctl load ${plistPath}`);
+			console.log(chalk.default.green("  ✅ LaunchAgent installed"));
+		} catch {
+			console.log(chalk.default.gray(`  Written: ${plistPath}`));
+		}
+	}
+	async reload(port, authToken) {
+		try {
+			const ws$1 = new ws.WebSocket(`ws://127.0.0.1:${port}`);
+			await new Promise((resolve, reject) => {
+				ws$1.on("open", () => {
+					if (authToken) ws$1.send(JSON.stringify({
+						type: "auth",
+						token: authToken
+					}));
+					ws$1.send(JSON.stringify({ type: "config:reload" }));
+					setTimeout(() => {
+						ws$1.close();
+						resolve();
+					}, 400);
+				});
+				ws$1.on("error", reject);
+				setTimeout(() => {
+					ws$1.terminate();
+					resolve();
+				}, 2e3);
+			});
+			console.log(chalk.default.green("  ✅ Gateway reloaded"));
+		} catch {
+			console.log(chalk.default.yellow("  ⚠  Gateway not running — changes apply on next start"));
+		}
+	}
+};
+
+//#endregion
+//#region src/cli/providers.ts
+const PROVIDERS = [
+	{
+		id: "anthropic",
+		displayName: "🎭 Anthropic (API Key)",
+		authType: "api_key",
+		authLabel: "Anthropic API Key",
+		authHint: "console.anthropic.com → API Keys",
+		models: [
+			{
+				id: "claude-opus-4-5",
+				name: "Claude Opus 4.5",
+				contextK: 200,
+				reasoning: true,
+				flagship: true
+			},
+			{
+				id: "claude-sonnet-4-5",
+				name: "Claude Sonnet 4.5",
+				contextK: 200,
+				reasoning: true
+			},
+			{
+				id: "claude-haiku-4-5",
+				name: "Claude Haiku 4.5",
+				contextK: 200,
+				fast: true
+			}
+		]
+	},
+	{
+		id: "anthropic-oauth",
+		displayName: "🎭 Anthropic (OAuth — Claude Code/Max)",
+		authType: "oauth",
+		authLabel: "Claude OAuth credentials",
+		authHint: "Reuses ~/.claude/.credentials.json (Claude Code CLI) or macOS Keychain \"Claude Code-credentials\"",
+		models: [{
+			id: "claude-opus-4-5",
+			name: "Claude Opus 4.5",
+			contextK: 200,
+			reasoning: true,
+			flagship: true
+		}, {
+			id: "claude-sonnet-4-5",
+			name: "Claude Sonnet 4.5",
+			contextK: 200,
+			reasoning: true
+		}]
+	},
+	{
+		id: "anthropic-setup-token",
+		displayName: "🎭 Anthropic (setup-token)",
+		authType: "api_key",
+		authLabel: "Anthropic setup-token",
+		authHint: "Run `claude setup-token` on any machine → paste the token here",
+		models: [{
+			id: "claude-opus-4-5",
+			name: "Claude Opus 4.5",
+			contextK: 200,
+			reasoning: true,
+			flagship: true
+		}, {
+			id: "claude-sonnet-4-5",
+			name: "Claude Sonnet 4.5",
+			contextK: 200,
+			reasoning: true
+		}]
+	},
+	{
+		id: "vercel-ai",
+		displayName: "▲ Vercel AI Gateway",
+		authType: "api_key",
+		authLabel: "Vercel AI Gateway API Key",
+		authHint: "vercel.com/docs/ai — multi-model proxy (AI_GATEWAY_API_KEY)",
+		baseUrl: "https://ai-gateway.vercel.sh/v1",
+		models: [
+			{
+				id: "openai/gpt-4o",
+				name: "GPT-4o (via Vercel)",
+				contextK: 128,
+				flagship: true
+			},
+			{
+				id: "anthropic/claude-sonnet-4-5",
+				name: "Claude Sonnet (via Vercel)",
+				contextK: 200
+			},
+			{
+				id: "google/gemini-2.0-flash",
+				name: "Gemini 2.0 Flash (via Vercel)",
+				contextK: 1e3,
+				fast: true
+			}
+		]
+	},
+	{
+		id: "opencode-zen",
+		displayName: "🧘 OpenCode Zen (multi-model proxy)",
+		authType: "api_key",
+		authLabel: "OpenCode Zen API Key",
+		authHint: "opencode.ai/auth — OPENCODE_API_KEY",
+		baseUrl: "https://api.opencode.ai/v1",
+		models: [{
+			id: "auto",
+			name: "Auto (best available)",
+			contextK: 200,
+			flagship: true
+		}]
+	},
+	{
+		id: "openrouter",
+		displayName: "🌐 OpenRouter",
+		authType: "api_key",
+		authLabel: "OpenRouter API Key",
+		authHint: "openrouter.ai/keys",
+		baseUrl: "https://openrouter.ai/api/v1",
+		supportsTranscription: true,
+		models: [
+			{
+				id: "openrouter/auto",
+				name: "Auto (best available)",
+				contextK: 200,
+				flagship: true
+			},
+			{
+				id: "anthropic/claude-opus-4.6",
+				name: "Claude Opus 4.6 (via OR)",
+				contextK: 200,
+				reasoning: true
+			},
+			{
+				id: "anthropic/claude-sonnet-4.5",
+				name: "Claude Sonnet 4.5 (via OR)",
+				contextK: 200
+			},
+			{
+				id: "openai/gpt-4o",
+				name: "GPT-4o",
+				contextK: 128,
+				vision: true
+			},
+			{
+				id: "openai/o3",
+				name: "o3 (reasoning)",
+				contextK: 200,
+				reasoning: true
+			},
+			{
+				id: "google/gemini-2.0-flash",
+				name: "Gemini 2.0 Flash",
+				contextK: 1e3,
+				fast: true
+			},
+			{
+				id: "google/gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextK: 1e3,
+				reasoning: true
+			},
+			{
+				id: "x-ai/grok-3",
+				name: "Grok 3",
+				contextK: 131,
+				reasoning: true
+			},
+			{
+				id: "deepseek/deepseek-r1",
+				name: "DeepSeek R1",
+				contextK: 64,
+				reasoning: true
+			},
+			{
+				id: "meta-llama/llama-3.3-70b-instruct",
+				name: "Llama 3.3 70B",
+				contextK: 128
+			},
+			{
+				id: "qwen/qwen-2.5-72b-instruct",
+				name: "Qwen 2.5 72B",
+				contextK: 128
+			},
+			{
+				id: "mistralai/mistral-large",
+				name: "Mistral Large",
+				contextK: 128
+			}
+		]
+	},
+	{
+		id: "openai",
+		displayName: "🧠 OpenAI",
+		authType: "api_key",
+		authLabel: "OpenAI API Key",
+		authHint: "platform.openai.com/api-keys",
+		supportsTranscription: true,
+		models: [
+			{
+				id: "gpt-4o",
+				name: "GPT-4o",
+				contextK: 128,
+				vision: true,
+				flagship: true
+			},
+			{
+				id: "gpt-4o-mini",
+				name: "GPT-4o Mini",
+				contextK: 128,
+				fast: true
+			},
+			{
+				id: "o3",
+				name: "o3 (reasoning)",
+				contextK: 200,
+				reasoning: true
+			},
+			{
+				id: "o4-mini",
+				name: "o4-mini (reasoning)",
+				contextK: 200,
+				reasoning: true,
+				fast: true
+			}
+		]
+	},
+	{
+		id: "google",
+		displayName: "🔍 Google",
+		authType: "api_key",
+		authLabel: "Google AI API Key",
+		authHint: "aistudio.google.com/app/apikey",
+		supportsTranscription: true,
+		models: [
+			{
+				id: "gemini-2.5-pro",
+				name: "Gemini 2.5 Pro",
+				contextK: 1e3,
+				reasoning: true,
+				flagship: true
+			},
+			{
+				id: "gemini-2.0-flash",
+				name: "Gemini 2.0 Flash",
+				contextK: 1e3,
+				fast: true
+			},
+			{
+				id: "gemini-1.5-pro",
+				name: "Gemini 1.5 Pro",
+				contextK: 2e3
+			}
+		]
+	},
+	{
+		id: "xai",
+		displayName: "⚡ xAI (Grok)",
+		authType: "api_key",
+		authLabel: "xAI API Key",
+		authHint: "console.x.ai",
+		models: [{
+			id: "grok-3",
+			name: "Grok 3",
+			contextK: 131,
+			reasoning: true,
+			flagship: true
+		}, {
+			id: "grok-3-mini",
+			name: "Grok 3 Mini",
+			contextK: 131,
+			fast: true
+		}]
+	},
+	{
+		id: "minimax",
+		displayName: "🎯 MiniMax",
+		authType: "api_key",
+		authLabel: "MiniMax API Key",
+		authHint: "platform.minimaxi.com",
+		models: [{
+			id: "MiniMax-Text-01",
+			name: "MiniMax Text-01",
+			contextK: 1e3,
+			flagship: true
+		}, {
+			id: "abab6.5s-chat",
+			name: "ABAB 6.5S",
+			contextK: 245
+		}]
+	},
+	{
+		id: "moonshot",
+		displayName: "🌙 Moonshot (Kimi)",
+		authType: "api_key",
+		authLabel: "Moonshot API Key",
+		authHint: "platform.moonshot.cn",
+		models: [{
+			id: "moonshot-v1-128k",
+			name: "Moonshot v1 128K",
+			contextK: 128,
+			flagship: true
+		}, {
+			id: "moonshot-v1-8k",
+			name: "Moonshot v1 8K",
+			contextK: 8,
+			fast: true
+		}]
+	},
+	{
+		id: "qwen",
+		displayName: "🐉 Qwen (Alibaba)",
+		authType: "api_key",
+		authLabel: "DashScope API Key",
+		authHint: "dashscope.aliyuncs.com",
+		models: [
+			{
+				id: "qwen-max",
+				name: "Qwen Max",
+				contextK: 32,
+				flagship: true
+			},
+			{
+				id: "qwen-plus",
+				name: "Qwen Plus",
+				contextK: 128
+			},
+			{
+				id: "qwen-turbo",
+				name: "Qwen Turbo",
+				contextK: 128,
+				fast: true
+			},
+			{
+				id: "qwen3-235b-a22b",
+				name: "Qwen3 235B",
+				contextK: 32,
+				reasoning: true
+			}
+		]
+	},
+	{
+		id: "zai",
+		displayName: "🔧 Z.AI",
+		authType: "api_key",
+		authLabel: "Z.AI API Key",
+		authHint: "z.ai",
+		models: [{
+			id: "glm-4-plus",
+			name: "GLM-4 Plus",
+			contextK: 128,
+			flagship: true
+		}, {
+			id: "glm-4-flash",
+			name: "GLM-4 Flash",
+			contextK: 128,
+			fast: true
+		}]
+	},
+	{
+		id: "litellm",
+		displayName: "🔀 LiteLLM (proxy)",
+		authType: "api_key",
+		authLabel: "LiteLLM Master Key",
+		authHint: "Your self-hosted LiteLLM proxy key",
+		models: [{
+			id: "gpt-4o",
+			name: "GPT-4o (via proxy)",
+			contextK: 128,
+			flagship: true
+		}]
+	},
+	{
+		id: "cloudflare",
+		displayName: "☁️  Cloudflare AI Gateway",
+		authType: "api_key",
+		authLabel: "Cloudflare API Token",
+		authHint: "dash.cloudflare.com → AI → Gateway",
+		models: [{
+			id: "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+			name: "Llama 3.3 70B (CF)",
+			contextK: 128,
+			flagship: true
+		}]
+	},
+	{
+		id: "copilot",
+		displayName: "🤖 GitHub Copilot",
+		authType: "oauth",
+		authLabel: "GitHub OAuth Token",
+		authHint: "github.com/settings/tokens",
+		models: [{
+			id: "gpt-4o",
+			name: "GPT-4o (Copilot)",
+			contextK: 128,
+			flagship: true
+		}, {
+			id: "claude-sonnet-4-5",
+			name: "Claude Sonnet (Copilot)",
+			contextK: 200
+		}]
+	},
+	{
+		id: "custom",
+		displayName: "🔌 Custom (OpenAI-compatible API)",
+		authType: "api_key",
+		authLabel: "API Key",
+		authHint: "Any OpenAI-compatible /chat/completions API (e.g. Ads Power, Proxies, new LLM APIs)",
+		models: [{
+			id: "__manual__",
+			name: "Enter model ID manually",
+			contextK: 128,
+			flagship: true
+		}]
+	}
+];
+function getProvider(id) {
+	return PROVIDERS.find((p) => p.id === id);
+}
+/** Providers that support voice note transcription. Shown in wizard. */
+function getTranscriptionProviders() {
+	return PROVIDERS.filter((p) => p.supportsTranscription);
+}
+function formatModel(m) {
+	const badges = [];
+	if (m.flagship) badges.push(chalk.default.yellow("★"));
+	if (m.reasoning) badges.push(chalk.default.magenta("reasoning"));
+	if (m.fast) badges.push(chalk.default.green("fast"));
+	if (m.vision) badges.push(chalk.default.cyan("vision"));
+	const ctx = m.contextK >= 1e3 ? `${m.contextK}K` : `${m.contextK}K`;
+	return `${badges.join(" ")} ${m.name} ${chalk.default.gray(`ctx ${ctx}`)}`.trim();
+}
+
+//#endregion
+//#region src/cli/channels.ts
+const CHANNEL_DEFS = [
+	{
+		id: "telegram",
+		name: "Telegram",
+		emoji: "✈️",
+		requiresGateway: false,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Telegram Bot Token",
+		tokenHint: "Get from @BotFather → /newbot",
+		setupSteps: [
+			"1. Open Telegram → @BotFather → /newbot",
+			"2. Set name and username (must end in bot)",
+			"3. Copy the Bot Token",
+			"  🔗 t.me/BotFather"
+		],
+		npmPackage: "node-telegram-bot-api",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "discord",
+		name: "Discord",
+		emoji: "🎮",
+		requiresGateway: false,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Discord Bot Token",
+		tokenHint: "discord.com/developers/applications",
+		setupSteps: [
+			"1. discord.com/developers/applications → New Application",
+			"2. Bot → Add Bot → Reset Token",
+			"3. OAuth2 → General → copy Application ID",
+			"  🔗 discord.com/developers/applications"
+		],
+		extraFields: [{
+			name: "clientId",
+			label: "Client ID",
+			required: true
+		}],
+		npmPackage: "discord.js",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "whatsapp",
+		name: "WhatsApp",
+		emoji: "📱",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "WhatsApp Business API key",
+		tokenHint: "business.whatsapp.com",
+		setupSteps: [
+			"1. developers.facebook.com → My Apps → Create App",
+			"2. WhatsApp → API Setup → Access Token",
+			"  🔗 business.whatsapp.com"
+		],
+		npmPackage: "@whiskeysockets/baileys",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "slack",
+		name: "Slack",
+		emoji: "💼",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Slack Bot Token (xoxb-...)",
+		tokenHint: "api.slack.com/apps",
+		setupSteps: [
+			"1. api.slack.com/apps → Create App → Bot",
+			"2. Install App → copy Bot Token (xoxb-)",
+			"3. Basic Information → Signing Secret",
+			"  🔗 api.slack.com/apps"
+		],
+		extraFields: [{
+			name: "signingSecret",
+			label: "Signing Secret",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "signal",
+		name: "Signal",
+		emoji: "🔒",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["linux", "darwin"],
+		tokenLabel: "Registered phone number",
+		tokenHint: "Requires signal-cli installed",
+		setupSteps: [
+			"1. Install signal-cli or signald",
+			"2. Link your number (signal-cli link or signald register)",
+			"  🔗 github.com/AsamK/signal-cli"
+		],
+		notes: "Needs signal-cli + registered number",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "imessage",
+		name: "iMessage",
+		emoji: "🍏",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["darwin"],
+		tokenLabel: "BlueBubbles server password",
+		tokenHint: "bluebubbles.app on macOS",
+		setupSteps: [
+			"1. Install BlueBubbles on a Mac",
+			"2. Configure and connect",
+			"  🔗 bluebubbles.app"
+		],
+		notes: "macOS only via BlueBubbles",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "imessage-native",
+		name: "iMessage (imsg)",
+		emoji: "💬",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["darwin"],
+		tokenLabel: "Not required",
+		tokenHint: "Uses imsg CLI",
+		setupSteps: [
+			"1. Install imsg CLI: brew install steipete/imsg/imsg",
+			"2. No token required — uses native iMessage",
+			"  🔗 github.com/steipete/imsg"
+		],
+		notes: "macOS only, native via imsg CLI (github.com/steipete/imsg). No BlueBubbles.",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "matrix",
+		name: "Matrix",
+		emoji: "🔢",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Matrix access token",
+		tokenHint: "element.io → Settings → Help → Access Token",
+		setupSteps: [
+			"1. Element → Settings → Help & About → Access Token",
+			"2. Copy the access token",
+			"  🔗 element.io"
+		],
+		extraFields: [{
+			name: "homeserver",
+			label: "Homeserver URL",
+			hint: "https://matrix.org",
+			required: true
+		}, {
+			name: "userId",
+			label: "User ID (@user:server)",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "email",
+		name: "Email",
+		emoji: "📧",
+		requiresGateway: false,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Gmail app password or IMAP password",
+		tokenHint: "Use app-specific password",
+		setupSteps: [
+			"1. Enable IMAP/SMTP in your email provider",
+			"2. Use app password if you have 2FA",
+			"  🔗 Gmail: myaccount.google.com/apppasswords"
+		],
+		extraFields: [
+			{
+				name: "imapHost",
+				label: "IMAP host",
+				hint: "imap.gmail.com",
+				required: true
+			},
+			{
+				name: "smtpHost",
+				label: "SMTP host",
+				hint: "smtp.gmail.com",
+				required: true
+			},
+			{
+				name: "user",
+				label: "Email address",
+				required: true
+			}
+		],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "feishu",
+		name: "Feishu/Lark",
+		emoji: "🪶",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Feishu App ID",
+		tokenHint: "open.feishu.cn",
+		setupSteps: [
+			"1. open.feishu.cn → Create application",
+			"2. Copy App ID and App Secret",
+			"  🔗 open.feishu.cn"
+		],
+		extraFields: [{
+			name: "appSecret",
+			label: "App Secret",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "msteams",
+		name: "MS Teams",
+		emoji: "🟦",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Azure Bot App ID",
+		tokenHint: "portal.azure.com → Bot Services",
+		setupSteps: [
+			"1. dev.botframework.com → Register Bot",
+			"2. Azure Bot → Configuration → copy App ID & Secret",
+			"  🔗 dev.botframework.com"
+		],
+		extraFields: [{
+			name: "appPassword",
+			label: "App Password",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "messenger",
+		name: "Messenger",
+		emoji: "💬",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Page Access Token",
+		tokenHint: "developers.facebook.com",
+		setupSteps: [
+			"1. developers.facebook.com → My Apps → Create App",
+			"2. Add Messenger product → Page Access Token",
+			"  🔗 developers.facebook.com"
+		],
+		extraFields: [{
+			name: "verifyToken",
+			label: "Webhook Verify Token",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "nostr",
+		name: "Nostr",
+		emoji: "🌐",
+		requiresGateway: false,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Nostr private key (hex or nsec)",
+		tokenHint: "Generate with: openssl rand -hex 32",
+		setupSteps: [
+			"1. Use existing nostr client or generate new keypair",
+			"2. Copy nsec (private key)",
+			"  🔗 nostr.com"
+		],
+		notes: "Decentralized — no account needed",
+		defaultDMPolicy: "open"
+	},
+	{
+		id: "line",
+		name: "LINE",
+		emoji: "💚",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "LINE Channel Access Token",
+		tokenHint: "developers.line.biz",
+		setupSteps: [
+			"1. developers.line.biz → Add Messaging API channel",
+			"2. Copy Channel Secret & Access Token",
+			"  🔗 developers.line.biz"
+		],
+		extraFields: [{
+			name: "channelSecret",
+			label: "Channel Secret",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "viber",
+		name: "Viber",
+		emoji: "💜",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Viber Auth Token",
+		tokenHint: "partners.viber.com",
+		setupSteps: [
+			"1. partners.viber.com → Create Bot",
+			"2. Copy the Auth Token",
+			"  🔗 partners.viber.com"
+		],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "zalo",
+		name: "Zalo OA",
+		emoji: "🔵",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Zalo OA Access Token",
+		tokenHint: "developers.zalo.me",
+		setupSteps: [
+			"1. developers.zalo.me → Create application",
+			"2. Copy App ID and Access Token",
+			"  🔗 developers.zalo.me"
+		],
+		extraFields: [{
+			name: "secretKey",
+			label: "Secret Key",
+			required: true
+		}],
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "twitter",
+		name: "Twitter/X DM",
+		emoji: "🐦",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Twitter API Key",
+		tokenHint: "developer.twitter.com",
+		setupSteps: [
+			"1. developer.twitter.com → Developer Portal",
+			"2. Create Project & App → copy API keys",
+			"  🔗 developer.twitter.com"
+		],
+		extraFields: [
+			{
+				name: "apiKeySecret",
+				label: "API Key Secret",
+				required: true
+			},
+			{
+				name: "accessToken",
+				label: "Access Token",
+				required: true
+			},
+			{
+				name: "accessTokenSecret",
+				label: "Access Token Secret",
+				required: true
+			}
+		],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "irc",
+		name: "IRC",
+		emoji: "📡",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "NickServ password (optional)",
+		tokenHint: "freenode, libera.chat, etc.",
+		setupSteps: [
+			"1. Choose IRC server (e.g. irc.libera.chat)",
+			"2. Configure nick and password if needed",
+			"  🔗 libera.chat"
+		],
+		extraFields: [{
+			name: "server",
+			label: "IRC server",
+			hint: "irc.libera.chat",
+			required: true
+		}, {
+			name: "nick",
+			label: "Nickname",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "mattermost",
+		name: "Mattermost",
+		emoji: "🏗️",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Mattermost bot token",
+		tokenHint: "Settings → Integrations → Bot Accounts",
+		setupSteps: [
+			"1. Mattermost → Account Settings → Security → Personal Access Tokens",
+			"2. Create token and copy it",
+			"  🔗 docs.mattermost.com"
+		],
+		extraFields: [{
+			name: "serverUrl",
+			label: "Server URL",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "nextcloud",
+		name: "Nextcloud Talk",
+		emoji: "☁️",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Nextcloud app password",
+		tokenHint: "Your Nextcloud server",
+		setupSteps: [
+			"1. Nextcloud Admin → OAuth → new client",
+			"2. Talk → view bot credentials",
+			"  🔗 nextcloud.com"
+		],
+		extraFields: [{
+			name: "serverUrl",
+			label: "Nextcloud URL",
+			required: true
+		}, {
+			name: "username",
+			label: "Username",
+			required: true
+		}],
+		defaultDMPolicy: "allowlist"
+	},
+	{
+		id: "googlechat",
+		name: "Google Chat",
+		emoji: "🔵",
+		requiresGateway: true,
+		supportsDM: false,
+		platforms: ["all"],
+		tokenLabel: "Google Chat Webhook URL",
+		tokenHint: "chat.google.com → Space → Apps & Integrations",
+		setupSteps: [
+			"1. chat.google.com → Space → Apps & Integrations → Manage webhooks",
+			"2. Add webhook and copy the URL",
+			"  🔗 chat.google.com"
+		],
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "whatsapp-baileys",
+		name: "WhatsApp (Baileys)",
+		emoji: "📲",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Not required — scans QR code on first run",
+		setupSteps: [
+			"1. No Meta Business API needed — uses WhatsApp Web protocol",
+			"2. Start the gateway — a QR code will appear in the terminal",
+			"3. Open WhatsApp on your phone → Linked Devices → Link a device",
+			"4. Scan the QR code. Session is saved — no QR needed on future starts",
+			"  🔗 github.com/WhiskeySockets/Baileys"
+		],
+		notes: "WhatsApp Web via Baileys — no Meta Business needed. QR scan on first run.",
+		npmPackage: "@whiskeysockets/baileys",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "instagram",
+		name: "Instagram DMs",
+		emoji: "📸",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Meta Page Access Token",
+		tokenHint: "developers.facebook.com → Instagram product",
+		setupSteps: [
+			"1. Meta for Developers → My Apps → Create App → Business",
+			"2. Add Instagram product → Connect Instagram Business account",
+			"3. Webhooks: subscribe to messages, URL: https://<host>/webhook/instagram",
+			"4. Copy Page Access Token from Graph API Explorer (pages_messaging scope)",
+			"  🔗 developers.facebook.com"
+		],
+		extraFields: [{
+			name: "instagramAccountId",
+			label: "Instagram Business Account ID",
+			required: true
+		}, {
+			name: "verifyToken",
+			label: "Webhook Verify Token (any string)",
+			required: true
+		}],
+		notes: "Requires Instagram Business + Meta App",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "zalo-personal",
+		name: "Zalo Personal",
+		emoji: "🔵",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Zalo cookie token",
+		tokenHint: "Extracted from browser session",
+		setupSteps: [
+			"1. Open Zalo Web in browser (chat.zalo.me)",
+			"2. Open DevTools → Application → Cookies → find zpw_sek or _zlang",
+			"3. Copy the session cookie value",
+			"  ⚠  Unofficial API — may break on Zalo updates. Use at your own risk."
+		],
+		notes: "Unofficial — uses Zalo Personal API. May break on updates.",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "voice-call",
+		name: "Voice Call",
+		emoji: "🎙️",
+		requiresGateway: true,
+		supportsDM: false,
+		platforms: ["all"],
+		tokenLabel: "Not required",
+		setupSteps: [
+			"1. No external account needed",
+			"2. Requires microphone + ElevenLabs API key for TTS (optional)",
+			"3. Start with: hyperclaw voice-call",
+			"  💡 Works in terminal — voice input → agent → voice output"
+		],
+		notes: "Terminal voice session — hyperclaw voice-call",
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "web",
+		name: "WebChat UI",
+		emoji: "🌐",
+		requiresGateway: true,
+		supportsDM: false,
+		platforms: ["all"],
+		setupSteps: [
+			"1. Built-in — no setup needed",
+			"2. Start gateway: hyperclaw gateway",
+			"3. Open: http://localhost:<port>/dashboard",
+			"  💡 Works in any browser on your local network"
+		],
+		notes: "Built-in WebChat at http://localhost:<port>",
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "cli",
+		name: "CLI / Terminal",
+		emoji: "🖥️",
+		requiresGateway: false,
+		supportsDM: false,
+		platforms: ["all"],
+		setupSteps: [
+			"1. Always active — no setup needed",
+			"2. Use: hyperclaw chat  or  hyperclaw agent --message \"...\"",
+			"  💡 Works offline without any channel configured"
+		],
+		notes: "Always active — hyperclaw chat",
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "chrome-extension",
+		name: "Chrome Extension",
+		emoji: "🔌",
+		requiresGateway: true,
+		supportsDM: false,
+		platforms: ["all"],
+		setupSteps: [
+			"1. Open Chrome → chrome://extensions → Enable Developer mode",
+			"2. Load unpacked → select: extensions/chrome-extension/",
+			"3. Extension connects to gateway via WebSocket automatically",
+			"  💡 Gives the agent access to your browser context"
+		],
+		notes: "Load extensions/chrome-extension/ as unpacked extension in Chrome",
+		defaultDMPolicy: "none"
+	},
+	{
+		id: "synology-chat",
+		name: "Synology Chat",
+		emoji: "🖥️",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Incoming Webhook URL",
+		tokenHint: "DSM → Synology Chat → Integration → Incoming Webhooks",
+		setupSteps: [
+			"1. Open Synology Chat (DSM package)",
+			"2. Top-right menu → Integration → Incoming Webhooks → Create",
+			"3. Copy the Webhook URL (used to POST messages from HyperClaw)",
+			"4. Outgoing Webhook: Integration → Outgoing Webhooks → Create",
+			"     URL: http://<your-server>:7789/synology-hook",
+			"     Method: POST",
+			"  🔗 kb.synology.com/synologychat"
+		],
+		extraFields: [{
+			name: "webhookPort",
+			label: "Outgoing webhook port",
+			hint: "7789",
+			required: false
+		}, {
+			name: "webhookToken",
+			label: "Outgoing webhook token (optional HMAC)",
+			required: false
+		}],
+		notes: "Requires Synology Chat installed on your Synology NAS (DSM 7+)",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "tlon",
+		name: "Tlon (Urbit)",
+		emoji: "🪐",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "Urbit login code",
+		tokenHint: "From your Urbit ship: +code",
+		setupSteps: [
+			"1. Start your Urbit ship (e.g. via Port or urbit binary)",
+			"2. In the Dojo: +code  → copy the code",
+			"3. Note your ship name (e.g. ~sampel-palnet) and ship URL",
+			"4. Optionally configure a group: ~sampel-palnet/my-group",
+			"  🔗 tlon.io · urbit.org/getting-started"
+		],
+		extraFields: [
+			{
+				name: "shipUrl",
+				label: "Ship URL",
+				hint: "http://localhost:8080",
+				required: true
+			},
+			{
+				name: "ship",
+				label: "Ship name",
+				hint: "~sampel-palnet",
+				required: true
+			},
+			{
+				name: "group",
+				label: "Group path (optional)",
+				hint: "~sampel-palnet/my-group",
+				required: false
+			}
+		],
+		notes: "Requires a running Urbit ship with Tlon/Groups installed",
+		defaultDMPolicy: "pairing"
+	},
+	{
+		id: "twitch",
+		name: "Twitch",
+		emoji: "🟣",
+		requiresGateway: true,
+		supportsDM: true,
+		platforms: ["all"],
+		tokenLabel: "OAuth token (oauth:xxxxxxx)",
+		tokenHint: "twitchapps.com/tmi → connect with your bot account",
+		setupSteps: [
+			"1. Create a Twitch bot account (or use your own)",
+			"2. Go to: twitchapps.com/tmi → Connect → copy the OAuth token",
+			"3. Token format: oauth:xxxxxxxxxxxxxxxxxxxxxx",
+			"4. Bot username = the Twitch account you logged in with",
+			"  💡 To receive commands, users type: !<message>",
+			"  💡 Moderators and the broadcaster bypass the allowlist by default",
+			"  🔗 twitchapps.com/tmi"
+		],
+		extraFields: [
+			{
+				name: "username",
+				label: "Bot Twitch username (lowercase)",
+				required: true
+			},
+			{
+				name: "channels",
+				label: "Channel(s) to join (comma-separated)",
+				hint: "mychannel or mychannel,otherchannel",
+				required: true
+			},
+			{
+				name: "commandPrefix",
+				label: "Command prefix",
+				hint: "! (default)",
+				required: false
+			}
+		],
+		notes: "Chat-based; uses Twitch IRC over WebSocket. Command prefix required (default: !)",
+		defaultDMPolicy: "pairing"
+	}
+];
+async function getChannelStatus(def, configuredIds) {
+	const platform = os.default.platform();
+	if (!def.platforms.includes("all") && !def.platforms.includes(platform)) return "unavailable";
+	if (configuredIds.includes(def.id)) return "configured";
+	if (["telegram", "discord"].includes(def.id)) return "recommended";
+	return "available";
+}
+/** Human-readable reason why a channel is unavailable on this OS */
+function unavailableReason(def) {
+	const platform = os.default.platform();
+	if (def.platforms.length === 1 && def.platforms[0] === "darwin") return "macOS only";
+	if (def.platforms.includes("linux") && def.platforms.includes("darwin") && !def.platforms.includes("win32")) return "Linux/macOS only";
+	if (!def.platforms.includes("all") && !def.platforms.includes(platform)) return `not supported on ${platform}`;
+	return "unavailable on this OS";
+}
+function statusBadge(status, def) {
+	switch (status) {
+		case "configured": return chalk.default.green("[configured]");
+		case "recommended": return chalk.default.cyan("[recommended]");
+		case "available": return chalk.default.gray("[available]");
+		case "unavailable": {
+			const reason = def ? unavailableReason(def) : "unavailable";
+			return chalk.default.red(`[${reason}]`);
+		}
+	}
+}
+const CHANNELS = CHANNEL_DEFS;
+async function getAvailableChannels(configuredIds = []) {
+	const result = [];
+	for (const def of CHANNEL_DEFS) {
+		const status = await getChannelStatus(def, configuredIds);
+		result.push({
+			...def,
+			status
+		});
+	}
+	return result;
+}
+
+//#endregion
+//#region src/cli/memory.ts
+const HC_DIR = path.default.join(os.default.homedir(), ".hyperclaw");
+const AGENTS_FILE = path.default.join(HC_DIR, "AGENTS.md");
+const MEMORY_FILE = path.default.join(HC_DIR, "MEMORY.md");
+const SOUL_FILE = path.default.join(HC_DIR, "SOUL.md");
+const LOG_DIR = path.default.join(HC_DIR, "logs");
+var MemoryManager = class {
+	async init(opts = {}) {
+		await fs_extra.default.ensureDir(HC_DIR);
+		await fs_extra.default.ensureDir(LOG_DIR);
+		const agentName = opts.agentName || "HyperClaw";
+		const userName = opts.userName || os.default.userInfo().username;
+		const lang = opts.language || "English";
+		const personality = opts.personality || "Direct and efficient, helpful without being sycophantic, honest about uncertainty";
+		const rules = opts.rules && opts.rules.length > 0 ? opts.rules.map((r, i) => `${i + 1}. ${r}`).join("\n") : `1. Always respond in the user's preferred language unless asked otherwise
+2. Be concise unless detail is explicitly requested
+3. Never share API keys, tokens, or secrets in responses
+4. If unsure, ask before acting — especially for destructive operations
+5. Log all PC access actions to ~/.hyperclaw/pc-access.log`;
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		if (!await fs_extra.default.pathExists(AGENTS_FILE)) await fs_extra.default.writeFile(AGENTS_FILE, `# AGENTS.md — Global Rules
+> All sessions and subagents must follow these rules.
+
+## Identity
+- Agent name: ${agentName}
+- User name: ${userName}
+- Primary language: ${lang}
+- Created: ${today}
+
+## Behavior Rules
+${rules}
+
+## DM Policy Default
+- Require pairing before responding to unknown senders
+- Allowlist: (add trusted IDs here)
+
+## Hierarchy
+- SOUL.md: persona and values (read-only by subagents)
+- AGENTS.md: operational rules (this file)
+- MEMORY.md: accumulated facts about the user
+`);
+		if (!await fs_extra.default.pathExists(MEMORY_FILE)) await fs_extra.default.writeFile(MEMORY_FILE, `# MEMORY.md — User Context
+> Automatically updated by HyperClaw after each session.
+
+## User Profile
+- Name: ${userName}
+- Language: ${lang}
+- Initialized: ${today}
+
+## Notes
+(auto-populated from conversations)
+`);
+		if (!await fs_extra.default.pathExists(SOUL_FILE)) await fs_extra.default.writeFile(SOUL_FILE, `# SOUL.md — Agent Persona
+> Who I am and how I behave.
+
+## Name
+${agentName}
+
+## Personality
+- ${personality.replace(/\n/g, "\n- ")}
+
+## Values
+- User autonomy first
+- Do no harm
+- Transparency about capabilities and limits
+
+## Wake phrase
+${opts.wakeWord ? opts.wakeWord : `Wake up, ${agentName}! Your user ${userName} needs you.`}
+`);
+		const logFile = path.default.join(LOG_DIR, `${today}.md`);
+		if (!await fs_extra.default.pathExists(logFile)) await fs_extra.default.writeFile(logFile, `# Session Log — ${today}\n\n`);
+	}
+	async load() {
+		if (!await fs_extra.default.pathExists(AGENTS_FILE)) return null;
+		const agents = await fs_extra.default.readFile(AGENTS_FILE, "utf8").catch(() => "");
+		const memory = await fs_extra.default.readFile(MEMORY_FILE, "utf8").catch(() => "");
+		const soul = await fs_extra.default.readFile(SOUL_FILE, "utf8").catch(() => void 0);
+		return {
+			agents,
+			memory,
+			soul
+		};
+	}
+	async appendRule(rule) {
+		await fs_extra.default.ensureDir(HC_DIR);
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const line = `\n- ${today}: ${rule}\n`;
+		await fs_extra.default.appendFile(AGENTS_FILE, line);
+		console.log(chalk.default.green(`  ✅ Rule added to AGENTS.md: ${rule}`));
+	}
+	async addMemory(fact) {
+		await fs_extra.default.ensureDir(HC_DIR);
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		await fs_extra.default.appendFile(MEMORY_FILE, `\n- ${today}: ${fact}\n`);
+		console.log(chalk.default.green(`  ✅ Memory saved: ${fact}`));
+	}
+	async updateSoul(content) {
+		await fs_extra.default.ensureDir(HC_DIR);
+		await fs_extra.default.writeFile(SOUL_FILE, content);
+		console.log(chalk.default.green("  ✅ SOUL.md updated"));
+	}
+	async show() {
+		const data = await this.load();
+		if (!data) {
+			console.log(chalk.default.yellow("\n  No memory initialized. Run: hyperclaw init\n"));
+			return;
+		}
+		console.log(chalk.default.bold.cyan("\n  🧠 MEMORY\n"));
+		for (const [label, content] of [
+			["SOUL.md", data.soul],
+			["AGENTS.md", data.agents],
+			["MEMORY.md", data.memory]
+		]) {
+			if (!content) continue;
+			console.log(chalk.default.bold.white(`  ── ${label} ──`));
+			const lines = content.split("\n").slice(0, 20);
+			for (const line of lines) if (line.startsWith("#")) console.log(chalk.default.cyan(`  ${line}`));
+			else if (line.startsWith("-")) console.log(chalk.default.gray(`  ${line}`));
+			else console.log(`  ${line}`);
+			console.log();
+		}
+	}
+	async runPersonaBootstrap() {
+		console.log(chalk.default.bold.cyan("\n  🌅 Wake up, my friend!\n"));
+		const { agentName } = await inquirer.default.prompt([{
+			type: "input",
+			name: "agentName",
+			message: "What should I call myself? (agent name)",
+			default: "HyperClaw"
+		}]);
+		const { userName } = await inquirer.default.prompt([{
+			type: "input",
+			name: "userName",
+			message: `What shall ${agentName} call you?`,
+			default: os.default.userInfo().username
+		}]);
+		console.log(chalk.default.green(`\n  ✨ I am ${agentName}. Hello, ${userName}.\n`));
+		return {
+			agentName,
+			userName
+		};
+	}
+	async getContextForAI() {
+		let context = "";
+		for (const [label, file] of [
+			["SOUL", SOUL_FILE],
+			["AGENTS", AGENTS_FILE],
+			["MEMORY", MEMORY_FILE]
+		]) if (await fs_extra.default.pathExists(file)) {
+			const content = await fs_extra.default.readFile(file, "utf8");
+			context += `## ${label}.md\n${content}\n\n`;
+		}
+		return context;
+	}
+	async search(query) {
+		const data = await this.load();
+		if (!data) {
+			console.log(chalk.default.gray("  No memory\n"));
+			return;
+		}
+		const allText = [
+			data.agents,
+			data.memory,
+			data.soul || ""
+		].join("\n");
+		const lines = allText.split("\n").filter((l) => l.toLowerCase().includes(query.toLowerCase()));
+		if (lines.length === 0) {
+			console.log(chalk.default.gray(`  Nothing found for "${query}"\n`));
+			return;
+		}
+		console.log(chalk.default.bold.cyan(`\n  🔍 "${query}"\n`));
+		lines.forEach((l) => console.log(`  ${l}`));
+		console.log();
+	}
+	async clear(file = "memory") {
+		const { confirm } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "confirm",
+			message: `Clear ${file === "all" ? "ALL memory files" : "MEMORY.md"}?`,
+			default: false
+		}]);
+		if (!confirm) return;
+		if (file === "all") {
+			await fs_extra.default.remove(AGENTS_FILE);
+			await fs_extra.default.remove(MEMORY_FILE);
+			await fs_extra.default.remove(SOUL_FILE);
+			console.log(chalk.default.green("  ✅ All memory cleared"));
+		} else {
+			await fs_extra.default.writeFile(MEMORY_FILE, "# MEMORY.md\n\n");
+			console.log(chalk.default.green("  ✅ MEMORY.md cleared"));
+		}
+	}
+};
+
+//#endregion
+//#region src/cli/security.ts
+async function showSecurityDisclaimer() {
+	console.clear();
+	console.log(chalk.default.bgRed.white.bold("\n  ⚠️  SECURITY NOTICE — READ CAREFULLY  ⚠️ \n"));
+	console.log(chalk.default.white.bold("  A bad prompt can trick it into doing unsafe things\n"));
+	console.log(chalk.default.hex("#06b6d4")("  Protections to enable:"));
+	console.log(chalk.default.gray("  ● Pairing / allowlists  — limit who can DM your agent"));
+	console.log(chalk.default.gray("  ● Sandbox + least privilege  — restrict PC access level"));
+	console.log(chalk.default.gray("  ● Keep secrets out  — never put tokens in SOUL.md"));
+	console.log(chalk.default.gray("  ● Use strongest model  — smarter = better at refusing tricks\n"));
+	const { understood } = await inquirer.default.prompt([{
+		type: "confirm",
+		name: "understood",
+		message: chalk.default.bold("I understand this is powerful and inherently risky. Continue?"),
+		default: false
+	}]);
+	if (!understood) console.log(chalk.default.gray("\n  Aborted. Come back when ready.\n"));
+	return understood;
+}
+async function configureDMPolicy(channelName) {
+	const { configureDMPolicy: cdmp } = await Promise.resolve().then(() => require("./security-BqNyT4ID.js"));
+	const res = await cdmp(channelName);
+	return {
+		dmPolicy: res.policy,
+		allowFrom: res.allowFrom ?? []
+	};
+}
+
+//#endregion
+//#region src/terminal/banner.ts
+require_theme.init_theme();
+var Banner = class {
+	async showNeonBanner(daemonMode = false) {
+		console.clear();
+		const t = require_theme.getTheme(daemonMode);
+		const icon$1 = daemonMode ? "🩸" : "🦅";
+		try {
+			const title = figlet.default.textSync("HYPERCLAW", { font: "ANSI Shadow" });
+			const g = (0, gradient_string.default)(t.gradient);
+			const lines = title.split("\n");
+			const first = lines[0] ?? "";
+			console.log(`\n  ${icon$1} ` + g(first));
+			for (let i = 1; i < lines.length; i++) console.log(g("     " + (lines[i] ?? "")));
+		} catch {
+			console.log(chalk.default.bold.red(`\n  ${icon$1} HYPERCLAW\n`));
+		}
+		const subtitle = daemonMode ? chalk.default.hex(t.daemonPrimary)("    🩸 DAEMON MODE — ALWAYS WATCHING ⚡\n") : t.muted("    🦅 HyperClaw Bot — AI Gateway v5.0.0 ⚡\n");
+		console.log(subtitle);
+		const boxOpts = {
+			padding: 1,
+			margin: {
+				top: 1,
+				bottom: 1
+			},
+			borderStyle: "round",
+			borderColor: daemonMode ? t.daemonBorderColor : t.borderColor
+		};
+		if (t.boxBg) boxOpts.backgroundColor = t.boxBg;
+		const box = (0, boxen.default)(`${t.a("●")} GATEWAY READY    ${t.a("◆")} PROVIDERS: 8    ${t.a("⚡")} CHANNELS: 27    ` + (daemonMode ? `${t.d("🩸")} DAEMON` : `${t.a("🦅")} HYPERCLAW`), boxOpts);
+		console.log(box);
+		console.log(t.muted("  One assistant. All your channels. 🦅\n"));
+		const { maybeShowUpdateNotice } = await Promise.resolve().then(() => require("./update-check-C2Dz85wJ.js"));
+		maybeShowUpdateNotice(daemonMode);
+	}
+	async showMiniBanner() {
+		await this.showNeonBanner(false);
+	}
+	async showWizardBanner() {
+		console.clear();
+		const t = require_theme.getTheme(false);
+		const g = (0, gradient_string.default)(t.gradient);
+		try {
+			const title = figlet.default.textSync("HYPERCLAW", { font: "ANSI Shadow" });
+			const lines = title.split("\n");
+			const first = lines[0] ?? "";
+			console.log("\n  🦅 " + g(first));
+			for (let i = 1; i < lines.length; i++) console.log(g("     " + (lines[i] ?? "")));
+		} catch {
+			console.log(t.bold("\n  🦅 HYPERCLAW\n"));
+		}
+		console.log(t.muted("    🦅 HyperClaw Bot — AI Gateway • SETUP WIZARD v5.0.0 ⚡\n"));
+		const boxOpts = {
+			padding: 1,
+			margin: { bottom: 1 },
+			borderStyle: "round",
+			borderColor: t.borderColor
+		};
+		if (t.boxBg) boxOpts.backgroundColor = t.boxBg;
+		const box = (0, boxen.default)(t.a("◆") + " Provider • Channels • Gateway • Identity", boxOpts);
+		console.log(box);
+	}
+	async showStatus() {
+		const t = require_theme.getTheme(false);
+		const { ConfigManager } = await Promise.resolve().then(() => require("./manager-CrVDn6eN.js"));
+		const { GatewayManager: GatewayManager$1 } = await Promise.resolve().then(() => require("./manager-Bxl0sqlh.js"));
+		const cfg = await new ConfigManager().load();
+		const gm = new GatewayManager$1();
+		const port = cfg?.gateway?.port ?? 18789;
+		const running = await gm.isRunning(port);
+		console.log(t.bold("\n  🦅 HYPERCLAW STATUS\n"));
+		console.log(`  Gateway: ${running ? t.success("● running") : t.error("○ stopped")}  port ${port}`);
+		console.log(`  Provider: ${t.c(cfg?.provider?.providerId ?? "none")}`);
+		console.log(`  Channels: ${t.c(String((cfg?.channels ?? []).length))}`);
+		console.log();
+	}
+};
+
+//#endregion
+//#region src/infra/channel-icons.ts
+const CDN = "https://cdn.simpleicons.org";
+function icon(slug, name, color, darkColor) {
+	return {
+		slug,
+		name,
+		color,
+		url: `${CDN}/${slug}`,
+		darkColor
+	};
+}
+const CHANNEL_ICONS = {
+	"telegram": icon("telegram", "Telegram", "26A5E4"),
+	"discord": icon("discord", "Discord", "5865F2"),
+	"whatsapp": icon("whatsapp", "WhatsApp", "25D366"),
+	"whatsapp-baileys": icon("whatsapp", "WhatsApp (Baileys)", "25D366"),
+	"slack": icon("slack", "Slack", "4A154B"),
+	"signal": icon("signal", "Signal", "3A76F0", "FFFFFF"),
+	"imessage": icon("imessage", "iMessage", "29CC40"),
+	"imessage-native": icon("imessage", "iMessage (native)", "29CC40"),
+	"matrix": icon("matrix", "Matrix", "000000", "FFFFFF"),
+	"email": icon("gmail", "Email", "EA4335"),
+	"feishu": icon("lark", "Feishu / Lark", "00D6B9"),
+	"msteams": icon("microsoftteams", "Microsoft Teams", "6264A7"),
+	"messenger": icon("messenger", "Facebook Messenger", "00B2FF"),
+	"nostr": icon("nostr", "Nostr", "8E44AD", "C39BD3"),
+	"line": icon("line", "LINE", "00C300"),
+	"viber": icon("viber", "Viber", "7360F2"),
+	"zalo": icon("zalo", "Zalo", "0068FF"),
+	"zalo-personal": icon("zalo", "Zalo Personal", "0068FF"),
+	"twitter": icon("x", "Twitter / X", "000000", "FFFFFF"),
+	"irc": icon("irc", "IRC", "1A3B5C", "FFFFFF"),
+	"mattermost": icon("mattermost", "Mattermost", "0058CC"),
+	"nextcloud": icon("nextcloud", "Nextcloud Talk", "0082C9"),
+	"googlechat": icon("googlechat", "Google Chat", "00897B"),
+	"instagram": icon("instagram", "Instagram", "E4405F"),
+	"synology-chat": icon("synology", "Synology Chat", "B5B5B6", "FFFFFF"),
+	"tlon": icon("urbit", "Tlon (Urbit)", "000000", "FFFFFF"),
+	"twitch": icon("twitch", "Twitch", "9146FF"),
+	"voice-call": icon("webrtc", "Voice Call", "333333", "FFFFFF"),
+	"web": icon("googlechrome", "WebChat", "4285F4"),
+	"cli": icon("gnubash", "CLI / Terminal", "4EAA25", "FFFFFF"),
+	"chrome-extension": icon("googlechrome", "Chrome Extension", "4285F4")
+};
+const PROVIDER_ICONS = {
+	"anthropic": icon("anthropic", "Anthropic (Claude)", "D4C5A9", "191919"),
+	"openai": icon("openai", "OpenAI", "000000", "FFFFFF"),
+	"openrouter": icon("openrouter", "OpenRouter", "6467F2"),
+	"groq": icon("groq", "Groq", "F55036"),
+	"xai": icon("x", "xAI (Grok)", "000000", "FFFFFF"),
+	"custom": icon("jsonwebtokens", "Custom OpenAI API", "A0A0A0"),
+	"ollama": icon("ollama", "Ollama (local)", "000000", "FFFFFF"),
+	"mistral": icon("mistral", "Mistral AI", "FF7000"),
+	"cohere": icon("cohere", "Cohere", "39594D", "FFFFFF"),
+	"google": icon("googlegemini", "Google Gemini", "8E75B2"),
+	"deepseek": icon("deepseek", "DeepSeek", "4D6BFE"),
+	"together": icon("togetherai", "Together AI", "000000", "FFFFFF")
+};
+
+//#endregion
+//#region src/cli/onboard.ts
+/** Brand-colored ■ square — closest we can get to a real icon in a terminal */
+function brandIcon(id, type = "channel") {
+	const map = type === "channel" ? CHANNEL_ICONS : PROVIDER_ICONS;
+	const ic = map[id];
+	if (!ic) return chalk.default.gray("■");
+	return chalk.default.hex("#" + ic.color)("■");
+}
+var HyperClawWizard = class {
+	config = new ConfigStore();
+	daemon = new require_daemon.DaemonManager();
+	gateway = new GatewayManager();
+	async run(options) {
+		const existingCfg = await this.config.load();
+		const hasExistingConfig = !!(existingCfg && (existingCfg.provider || existingCfg.providers?.length));
+		if (hasExistingConfig && !options.nonInteractive) {
+			const { getConfigPath: getConfigPath$1 } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+			console.log(chalk.default.yellow(`\n  ⚡ Existing config detected: ${chalk.default.bold(getConfigPath$1())}\n`));
+			const { configAction } = await inquirer.default.prompt([{
+				type: "list",
+				name: "configAction",
+				message: "What would you like to do?",
+				choices: [
+					{
+						name: `${chalk.default.green("★")} Keep & modify    ${chalk.default.gray("(keep existing config, change specific settings)")}`,
+						value: "modify"
+					},
+					{
+						name: `  Keep & continue  ${chalk.default.gray("(re-run wizard, keep all current values as defaults)")}`,
+						value: "keep"
+					},
+					{
+						name: `${chalk.default.red("✖")} Reset             ${chalk.default.gray("(back up config and start fresh)")}`,
+						value: "reset"
+					}
+				]
+			}]);
+			if (configAction === "reset") {
+				const { resetScope } = await inquirer.default.prompt([{
+					type: "list",
+					name: "resetScope",
+					message: "Reset scope:",
+					choices: [
+						{
+							name: "Config only",
+							value: "config"
+						},
+						{
+							name: "Config + credentials + sessions",
+							value: "config+creds"
+						},
+						{
+							name: "Full reset (config + credentials + workspace)",
+							value: "full"
+						}
+					]
+				}]);
+				const fs$4 = await import("fs-extra");
+				const path$3 = await import("path");
+				const os$4 = await import("os");
+				const hcDir = path$3.join(os$4.homedir(), ".hyperclaw");
+				const backupDir = path$3.join(hcDir, `backup-${Date.now()}`);
+				await fs$4.ensureDir(backupDir);
+				const toRemove = [path$3.join(hcDir, "hyperclaw.json")];
+				if (resetScope !== "config") toRemove.push(path$3.join(hcDir, "credentials"), path$3.join(hcDir, "sessions"));
+				if (resetScope === "full") toRemove.push(path$3.join(hcDir, "workspace"));
+				for (const f of toRemove) if (await fs$4.pathExists(f)) await fs$4.move(f, path$3.join(backupDir, path$3.basename(f)));
+				console.log(chalk.default.green(`\n  ✔  Config backed up to ${backupDir}\n  Starting fresh...\n`));
+			} else if (configAction === "modify") console.log(chalk.default.gray("\n  Continuing with existing config as defaults...\n"));
+		}
+		const proceed = await showSecurityDisclaimer();
+		if (!proceed) return;
+		const { allThemes, getThemeName, setThemeName } = await Promise.resolve().then(() => require("./theme-cx0fkgWC.js"));
+		const currentTheme = getThemeName();
+		const { chosenTheme } = await inquirer.default.prompt([{
+			type: "list",
+			name: "chosenTheme",
+			message: "🎨 Choose a color theme:",
+			default: currentTheme,
+			choices: [
+				{
+					name: `${chalk.default.hex("#06b6d4")("■")} Dark Professional   ${chalk.default.gray("(neon cyan on black)")}`,
+					value: "dark"
+				},
+				{
+					name: `${chalk.default.hex("#64748b")("■")} Grey Professional   ${chalk.default.gray("(muted cyan, neutral)")}`,
+					value: "grey"
+				},
+				{
+					name: `${chalk.default.hex("#0284c7")("■")} White / Light       ${chalk.default.gray("(deep cyan, light bg)")}`,
+					value: "white"
+				}
+			]
+		}]);
+		if (chosenTheme !== currentTheme) await setThemeName(chosenTheme);
+		await new Banner().showWizardBanner();
+		const { mode } = await inquirer.default.prompt([{
+			type: "list",
+			name: "mode",
+			message: "Setup mode:",
+			choices: [{
+				name: `${chalk.default.green("★")} QuickStart        ${chalk.default.gray("(Recommended)")}`,
+				value: "quick"
+			}, {
+				name: `  Manual            ${chalk.default.gray("(Full control)")}`,
+				value: "manual"
+			}]
+		}]);
+		if (mode === "quick") return this.quickSetup(options);
+		return this.fullSetup(options);
+	}
+	async quickstart(options) {
+		const proceed = await showSecurityDisclaimer();
+		if (!proceed) return;
+		return this.quickSetup(options);
+	}
+	stepHeader(n, total, title) {
+		const { getTheme: getTheme$1 } = (require_theme.init_theme(), require_chunk.__toCommonJS(require_theme.theme_exports));
+		const t = getTheme$1(false);
+		const bar = chalk.default.gray("─".repeat(52));
+		console.log(`\n${bar}`);
+		console.log(`  ${t.c(`Step ${n} / ${total}`)}  ·  ${chalk.default.bold(title)}`);
+		console.log(`${bar}\n`);
+	}
+	async quickSetup(options) {
+		const STEPS = 7;
+		this.stepHeader(1, STEPS, "Workspace");
+		const { workspaceName } = await inquirer.default.prompt([{
+			type: "input",
+			name: "workspaceName",
+			message: "Workspace name:",
+			default: "my-hyperclaw"
+		}]);
+		this.stepHeader(2, STEPS, "AI Providers & Models");
+		const { providers: allProviders, primary: providerConfig } = await this.selectProvidersAndModels();
+		this.stepHeader(3, STEPS, "Gateway (optional)");
+		const gatewayConfig = await this.configureGateway(false);
+		this.stepHeader(4, STEPS, "Channels");
+		const channelConfigs = await this.selectChannels();
+		this.stepHeader(5, STEPS, "Agent Identity & Persona");
+		const identity = await this.configureIdentity();
+		this.stepHeader(6, STEPS, "Skills & Hooks");
+		const { hooks, heartbeat: heartbeatEnabled } = await this.configureSkillsAndHooks();
+		this.stepHeader(7, STEPS, "Extras");
+		const webSearch = await this.configureWebSearch(options.skipSearch);
+		const memoryIntegration = await this.configureMemoryIntegration();
+		const serviceApiKeys = await this.configureServiceApiKeys();
+		const hyperclawbotConfig = await this.configureHyperClawBot(gatewayConfig);
+		const talkModeConfig = await this.configureTalkMode();
+		const pcAccess = await this.configurePcAccess();
+		const updateChannel = await this.configureUpdateChannel();
+		const groupSandbox = await this.configureGroupSandbox();
+		await this.configureSkillHub();
+		await this.configureMcpServers();
+		await this.configureWorkspaceTemplate();
+		await this.configureCronTasks();
+		await this.configureAutoReply();
+		await this.configureWebhooks();
+		await this.configureNodes();
+		await this.configureOAuth();
+		await this.configureAgentBindings();
+		const rateLimit = await this.configureRateLimiting();
+		await this.configureDeveloperKey();
+		await this.configureVoiceCall();
+		await this.configureCanvas();
+		await this.configureDeploy();
+		await this.saveAll({
+			workspaceName,
+			providerConfig,
+			providers: allProviders,
+			channelConfigs,
+			gatewayConfig,
+			identity,
+			hooks,
+			heartbeatEnabled,
+			webSearch,
+			memoryIntegration,
+			serviceApiKeys,
+			hyperclawbotConfig,
+			talkModeConfig,
+			pcAccess,
+			updateChannel,
+			groupSandbox,
+			rateLimit
+		}, options);
+	}
+	async fullSetup(options) {
+		const STEPS = 9;
+		this.stepHeader(1, STEPS, "Workspace");
+		const { workspaceName } = await inquirer.default.prompt([{
+			type: "input",
+			name: "workspaceName",
+			message: "Workspace directory:",
+			default: "my-hyperclaw"
+		}]);
+		this.stepHeader(2, STEPS, "AI Providers & Models");
+		const { providers: allProviders, primary: providerConfig } = await this.selectProvidersAndModels();
+		this.stepHeader(3, STEPS, "Gateway");
+		const gatewayConfig = await this.configureGateway(true);
+		this.stepHeader(4, STEPS, "Channels");
+		const { configureChannels } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "configureChannels",
+			message: "Configure chat channels now?",
+			default: true
+		}]);
+		const channelConfigs = configureChannels ? await this.selectChannels(true) : {};
+		if (configureChannels) {
+			const { configureDM } = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "configureDM",
+				message: "Configure DM access policies now?",
+				default: true
+			}]);
+			if (configureDM) for (const [channelId] of Object.entries(channelConfigs)) {
+				const ch = CHANNELS.find((c) => c.id === channelId);
+				if (ch?.supportsDM) {
+					const dm = await configureDMPolicy(ch.name);
+					channelConfigs[channelId].dmPolicy = dm;
+				}
+			}
+		}
+		this.stepHeader(5, STEPS, "Agent Identity & Persona");
+		const identity = await this.configureIdentity();
+		this.stepHeader(6, STEPS, "Skills & Hooks");
+		const { hooks, heartbeat: heartbeatEnabled } = await this.configureSkillsAndHooks();
+		this.stepHeader(7, STEPS, "Services & Daemon");
+		let installDaemon = options.installDaemon ?? false;
+		let daemonRuntime = options.daemonRuntime ?? "node";
+		if (!installDaemon) {
+			console.log(chalk.default.gray("  The daemon runs the gateway as a background service that starts on boot.\n"));
+			const ans = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "installDaemon",
+				message: "Install as system daemon (auto-start on boot)?",
+				default: false
+			}, {
+				type: "list",
+				name: "daemonRuntime",
+				message: "Daemon runtime:",
+				default: "node",
+				choices: [{
+					name: `Node.js  ${chalk.default.green("(recommended)")} — required for WhatsApp/Telegram`,
+					value: "node"
+				}, {
+					name: `Bun      ${chalk.default.gray("(faster startup, experimental)")}`,
+					value: "bun"
+				}],
+				when: (answers) => answers.installDaemon
+			}]);
+			installDaemon = ans.installDaemon;
+			if (ans.daemonRuntime) daemonRuntime = ans.daemonRuntime;
+		} else console.log(chalk.default.green(`  ✔ Daemon will be installed (runtime: ${daemonRuntime})\n`));
+		this.stepHeader(8, STEPS, "Extras");
+		const webSearch = await this.configureWebSearch(options.skipSearch);
+		const memoryIntegration = await this.configureMemoryIntegration();
+		const serviceApiKeys = await this.configureServiceApiKeys();
+		const hyperclawbotConfig = await this.configureHyperClawBot(gatewayConfig);
+		const talkModeConfig = await this.configureTalkMode();
+		const pcAccess = await this.configurePcAccess();
+		const updateChannel = await this.configureUpdateChannel();
+		const groupSandbox = await this.configureGroupSandbox();
+		await this.configureSkillHub();
+		await this.configureMcpServers();
+		await this.configureWorkspaceTemplate();
+		await this.configureCronTasks();
+		await this.configureAutoReply();
+		await this.configureWebhooks();
+		await this.configureNodes();
+		await this.configureOAuth();
+		await this.configureAgentBindings();
+		const rateLimit = await this.configureRateLimiting();
+		await this.configureDeveloperKey();
+		await this.configureVoiceCall();
+		await this.configureCanvas();
+		await this.configureDeploy();
+		this.stepHeader(9, STEPS, "Launch");
+		const launchChoices = [{
+			name: `TUI  — terminal dashboard`,
+			value: "tui"
+		}];
+		if (gatewayConfig && !gatewayConfig.remote) launchChoices.push({
+			name: `Web  — browser at http://localhost:${gatewayConfig.port}`,
+			value: "web"
+		});
+		launchChoices.push({
+			name: chalk.default.gray("Do this later — I will start manually"),
+			value: "skip"
+		});
+		const { hatchMode } = await inquirer.default.prompt([{
+			type: "list",
+			name: "hatchMode",
+			message: "How do you want to hatch your bot?",
+			choices: launchChoices
+		}]);
+		await this.saveAll({
+			workspaceName,
+			providerConfig,
+			providers: allProviders,
+			channelConfigs,
+			gatewayConfig: gatewayConfig ? {
+				...gatewayConfig,
+				hooks: hooks.length > 0
+			} : null,
+			identity,
+			hooks,
+			heartbeatEnabled,
+			installDaemon,
+			daemonRuntime,
+			hatchMode,
+			webSearch,
+			memoryIntegration,
+			serviceApiKeys,
+			hyperclawbotConfig,
+			talkModeConfig,
+			pcAccess,
+			updateChannel,
+			groupSandbox,
+			rateLimit
+		}, options);
+	}
+	async selectProvidersAndModels() {
+		const { getTheme: getTheme$1 } = (require_theme.init_theme(), require_chunk.__toCommonJS(require_theme.theme_exports));
+		const t = getTheme$1(false);
+		console.log(chalk.default.gray("  Select one or more AI providers. The first one will be primary.\n"));
+		const { selectedProviderIds } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "selectedProviderIds",
+			message: "Select AI providers:",
+			validate: (v) => v.length > 0 || "Select at least one provider",
+			choices: PROVIDERS.map((p) => ({
+				name: `${brandIcon(p.id, "provider")} ${p.displayName.replace(/^.{1,2}\s/, "").padEnd(18)}${p.supportsTranscription ? chalk.default.gray(" 🎤") : ""}`,
+				value: p.id,
+				checked: p.id === "openrouter"
+			}))
+		}]);
+		const configured = [];
+		for (let i = 0; i < selectedProviderIds.length; i++) {
+			const pid = selectedProviderIds[i];
+			const provider = getProvider(pid);
+			const isPrimary = i === 0;
+			console.log(`\n  ${t.c("▸")} ${chalk.default.bold(provider.displayName)} ${isPrimary ? chalk.default.green("(primary)") : chalk.default.gray(`(#${i + 1})`)}\n`);
+			if (provider.authHint) console.log(chalk.default.gray(`    💡 ${provider.authHint}\n`));
+			let apiKey = "";
+			let baseUrl;
+			let modelId = "";
+			if (pid === "anthropic-oauth") {
+				const fs$4 = await import("fs-extra");
+				const path$3 = await import("path");
+				const os$4 = await import("os");
+				const credPath = path$3.join(os$4.homedir(), ".claude", ".credentials.json");
+				const credExists = await fs$4.pathExists(credPath);
+				if (credExists) {
+					console.log(chalk.default.green(`  ✔ Found Claude credentials: ${credPath}`));
+					console.log(chalk.default.gray("    HyperClaw will reuse these credentials automatically.\n"));
+					apiKey = "__claude_oauth__";
+				} else {
+					console.log(chalk.default.yellow(`  ⚠  ~/.claude/.credentials.json not found.\n`));
+					console.log(chalk.default.gray("  Run `claude` CLI on this machine first to authenticate,\n  or paste a setup-token (use \"Anthropic setup-token\" provider instead).\n"));
+					apiKey = "__claude_oauth__";
+				}
+			} else if (pid === "anthropic-setup-token") {
+				console.log(chalk.default.gray("  Run `claude setup-token` on any machine → paste the token below.\n"));
+				const r = await inquirer.default.prompt([{
+					type: "password",
+					name: "apiKey",
+					message: "  Setup token (sk-ant-setup-...):",
+					mask: "●",
+					validate: (v) => v.trim().length > 10 || "Required"
+				}]);
+				apiKey = r.apiKey.trim();
+			} else if (provider.authType === "api_key") if (pid === "custom") {
+				const r = await inquirer.default.prompt([
+					{
+						type: "input",
+						name: "baseUrl",
+						message: "  Base URL:",
+						validate: (v) => v.trim().length > 5 || "Required"
+					},
+					{
+						type: "password",
+						name: "apiKey",
+						message: `  ${provider.authLabel}:`,
+						mask: "●",
+						validate: (v) => v.trim().length > 5 || "Required"
+					},
+					{
+						type: "input",
+						name: "modelId",
+						message: "  Model ID:",
+						validate: (v) => v.trim().length > 0 || "Required"
+					}
+				]);
+				baseUrl = r.baseUrl.trim().replace(/\/$/, "");
+				apiKey = r.apiKey;
+				modelId = r.modelId.trim();
+			} else {
+				const r = await inquirer.default.prompt([{
+					type: "password",
+					name: "apiKey",
+					message: `  ${provider.authLabel}:`,
+					mask: "●"
+				}]);
+				apiKey = r.apiKey;
+			}
+			if (!modelId) {
+				const modelChoices = provider.models.filter((m) => m.id !== "__manual__").length ? [...provider.models.filter((m) => m.id !== "__manual__").map((m) => ({
+					name: formatModel(m),
+					value: m.id
+				})), {
+					name: chalk.default.gray("Enter manually..."),
+					value: "__manual__"
+				}] : [{
+					name: chalk.default.gray("Enter model ID manually"),
+					value: "__manual__"
+				}];
+				const { modelChoice } = await inquirer.default.prompt([{
+					type: "list",
+					name: "modelChoice",
+					message: "  Default model:",
+					choices: modelChoices
+				}]);
+				if (modelChoice === "__manual__") {
+					const { manual } = await inquirer.default.prompt([{
+						type: "input",
+						name: "manual",
+						message: "  Model ID:",
+						default: provider.models[0]?.id || ""
+					}]);
+					modelId = manual;
+				} else modelId = modelChoice;
+			}
+			const apiKeys = [];
+			if (apiKey) {
+				const { wantRotation } = await inquirer.default.prompt([{
+					type: "confirm",
+					name: "wantRotation",
+					message: `  Add extra API keys for rate-limit rotation? ${chalk.default.gray("(gateway cycles through on 429)")}`,
+					default: false
+				}]);
+				if (wantRotation) {
+					let addMore = true;
+					while (addMore) {
+						const { extraKey } = await inquirer.default.prompt([{
+							type: "password",
+							name: "extraKey",
+							message: `  Extra key #${apiKeys.length + 1}:`,
+							mask: "●"
+						}]);
+						if (extraKey.trim()) apiKeys.push(extraKey.trim());
+						const { more } = await inquirer.default.prompt([{
+							type: "confirm",
+							name: "more",
+							message: "  Add another?",
+							default: false
+						}]);
+						addMore = more;
+					}
+					if (apiKeys.length > 0) console.log(chalk.default.green(`  ✔ ${apiKeys.length} extra key(s) added for rotation\n`));
+				}
+			}
+			let thinking;
+			if (["anthropic", "openai"].includes(pid)) {
+				const { thinkingLevel } = await inquirer.default.prompt([{
+					type: "list",
+					name: "thinkingLevel",
+					message: `  Extended thinking / reasoning:`,
+					choices: [
+						{
+							name: `Off        ${chalk.default.gray("(standard responses)")}`,
+							value: "off"
+						},
+						{
+							name: `Standard   ${chalk.default.gray("(~8 000 token budget)")}`,
+							value: "standard"
+						},
+						{
+							name: `Extended   ${chalk.default.gray("(~32 000 token budget — slower, deeper)")}`,
+							value: "extended"
+						}
+					],
+					default: "off"
+				}]);
+				if (thinkingLevel !== "off") {
+					thinking = {
+						enabled: true,
+						budgetTokens: thinkingLevel === "extended" ? 32e3 : 8e3
+					};
+					console.log(chalk.default.green(`  ✔ Thinking: ${thinkingLevel} (${thinking.budgetTokens.toLocaleString()} tokens)\n`));
+				}
+			}
+			configured.push({
+				providerId: pid,
+				apiKey,
+				modelId,
+				...baseUrl ? { baseUrl } : {},
+				...apiKeys.length > 0 ? { apiKeys } : {},
+				...thinking ? { thinking } : {}
+			});
+			console.log(t.c(`  ✔ ${provider.displayName} → ${modelId}\n`));
+		}
+		return {
+			providers: configured,
+			primary: configured[0]
+		};
+	}
+	async configureGateway(full = false) {
+		const { gatewayMode } = await inquirer.default.prompt([{
+			type: "list",
+			name: "gatewayMode",
+			message: "Gateway setup:",
+			choices: [
+				{
+					name: `Local gateway   ${chalk.default.gray("(run on this machine)")}`,
+					value: "local"
+				},
+				{
+					name: `Remote gateway  ${chalk.default.gray("(info-only — connect to existing server)")}`,
+					value: "remote"
+				},
+				{
+					name: chalk.default.gray("Skip            (no gateway — CLI-only mode)"),
+					value: "skip"
+				}
+			]
+		}]);
+		if (gatewayMode === "skip") {
+			console.log(chalk.default.gray("  ↳ Gateway skipped. Enable later: hyperclaw gateway start\n"));
+			return null;
+		}
+		if (gatewayMode === "remote") {
+			const { remoteUrl } = await inquirer.default.prompt([{
+				type: "input",
+				name: "remoteUrl",
+				message: "Remote gateway URL (e.g. wss://myserver.com:18789):",
+				validate: (v) => v.startsWith("ws") || "Must start with ws:// or wss://"
+			}]);
+			const { remoteToken } = await inquirer.default.prompt([{
+				type: "password",
+				name: "remoteToken",
+				message: "Remote gateway auth token:",
+				mask: "●"
+			}]);
+			console.log(chalk.default.green("  ✔ Remote gateway configured\n"));
+			return {
+				port: 18789,
+				bind: remoteUrl,
+				authToken: remoteToken,
+				tailscaleExposure: "off",
+				runtime: "node",
+				enabledChannels: [],
+				hooks: true,
+				remote: true
+			};
+		}
+		const { useGateway } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "useGateway",
+			message: "Enable the local WebSocket gateway? (needed for channels, web UI, mobile apps)",
+			default: true
+		}]);
+		if (!useGateway) {
+			console.log(chalk.default.gray("  ↳ Gateway skipped. You can enable it later: hyperclaw gateway start\n"));
+			return null;
+		}
+		const running = await this.gateway.isRunning(18789);
+		if (running) console.log(chalk.default.gray(`  ⚠  Gateway already running at ws://127.0.0.1:18789`));
+		const detectedRuntime = await this.gateway.detectRuntime();
+		const questions = [{
+			type: "input",
+			name: "port",
+			message: "Gateway port:",
+			default: String(18789),
+			validate: (v) => Number(v) > 1024 && Number(v) < 65535 ? true : "Enter valid port (1024-65535)"
+		}];
+		if (full) questions.push({
+			type: "list",
+			name: "bind",
+			message: "Bind address:",
+			choices: [
+				{
+					name: `127.0.0.1  ${chalk.default.gray("Loopback only (secure)")}`,
+					value: "127.0.0.1"
+				},
+				{
+					name: `0.0.0.0   ${chalk.default.gray("All interfaces (LAN)")}`,
+					value: "0.0.0.0"
+				},
+				{
+					name: `Tailscale ${chalk.default.gray("VPN peers only")}`,
+					value: "tailscale"
+				},
+				{
+					name: `Custom    ${chalk.default.gray("Enter IP manually")}`,
+					value: "custom"
+				}
+			],
+			default: "127.0.0.1"
+		}, {
+			type: "list",
+			name: "tailscaleExposure",
+			message: "Tailscale exposure:",
+			choices: [
+				{
+					name: this.gateway.exposureLabel("off"),
+					value: "off"
+				},
+				{
+					name: this.gateway.exposureLabel("serve"),
+					value: "serve"
+				},
+				{
+					name: this.gateway.exposureLabel("funnel"),
+					value: "funnel"
+				}
+			],
+			default: "off",
+			when: (a) => a.bind === "tailscale"
+		}, {
+			type: "list",
+			name: "runtime",
+			message: "Runtime:",
+			choices: [
+				{
+					name: `Node.js  ${detectedRuntime === "node" ? chalk.default.green("(detected)") : ""}`,
+					value: "node"
+				},
+				{
+					name: `Bun      ${detectedRuntime === "bun" ? chalk.default.green("(detected)") : chalk.default.gray("(faster)")}`,
+					value: "bun"
+				},
+				{
+					name: `Deno     ${detectedRuntime === "deno" ? chalk.default.green("(detected)") : ""}`,
+					value: "deno"
+				}
+			],
+			default: detectedRuntime
+		});
+		questions.push({
+			type: "password",
+			name: "authToken",
+			message: `Auth token: ${chalk.default.gray("(blank = auto-generate)")}`,
+			mask: "●"
+		});
+		const answers = await inquirer.default.prompt(questions);
+		const token = answers.authToken || this.gateway.generateToken();
+		if (!answers.authToken) console.log(chalk.default.green("  ✔ Auth token auto-generated\n"));
+		const { wantSshTunnel } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantSshTunnel",
+			message: `SSH reverse tunnel for remote access? ${chalk.default.gray("(alternative to Tailscale)")}`,
+			default: false
+		}]);
+		let sshTunnel;
+		if (wantSshTunnel) {
+			const sshAns = await inquirer.default.prompt([
+				{
+					type: "input",
+					name: "host",
+					message: "  Remote SSH host (e.g. myserver.com):",
+					validate: (v) => v.trim().length > 3 || "Required"
+				},
+				{
+					type: "input",
+					name: "user",
+					message: "  SSH user:",
+					default: process.env.USER || process.env.USERNAME || "ubuntu"
+				},
+				{
+					type: "input",
+					name: "remotePort",
+					message: "  Remote port (forwarded on server):",
+					default: String(Number(answers.port) || 18789),
+					validate: (v) => Number(v) > 1024 && Number(v) < 65535 ? true : "Valid port required"
+				}
+			]);
+			sshTunnel = {
+				enabled: true,
+				host: sshAns.host.trim(),
+				user: sshAns.user.trim(),
+				remotePort: Number(sshAns.remotePort)
+			};
+			console.log(chalk.default.green(`  ✔ SSH tunnel: ${sshTunnel.user}@${sshTunnel.host}:${sshTunnel.remotePort}\n`));
+			console.log(chalk.default.gray(`  Run: ssh -R ${sshTunnel.remotePort}:localhost:${Number(answers.port)} ${sshTunnel.user}@${sshTunnel.host}\n`));
+		}
+		return {
+			port: Number(answers.port),
+			bind: answers.bind || "127.0.0.1",
+			authToken: token,
+			tailscaleExposure: answers.tailscaleExposure || "off",
+			runtime: answers.runtime || detectedRuntime,
+			enabledChannels: [],
+			hooks: true,
+			...sshTunnel ? { sshTunnel } : {}
+		};
+	}
+	async selectChannels(full = false) {
+		console.log(chalk.default.hex("#06b6d4")("\n  📱 Communication Channels\n"));
+		const available = await getAvailableChannels();
+		const { selectedChannels } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "selectedChannels",
+			message: "Enable channels:",
+			choices: available.map((ch) => {
+				const isUnavailable = ch.status === "unavailable";
+				const reason = isUnavailable ? unavailableReason(ch) : "";
+				const icon$1 = brandIcon(ch.id, "channel");
+				return {
+					name: `${icon$1} ${ch.name.padEnd(18)} ${statusBadge(ch.status, ch)}${ch.requiresGateway && !isUnavailable ? chalk.default.gray(" [needs gateway]") : ""}`,
+					value: ch.id,
+					checked: ch.status === "recommended",
+					disabled: isUnavailable ? reason : false
+				};
+			})
+		}]);
+		const channelConfigs = {};
+		for (const channelId of selectedChannels) {
+			const ch = CHANNELS.find((c) => c.id === channelId);
+			if (!ch || !ch.tokenLabel) continue;
+			console.log(chalk.default.hex("#06b6d4")(`\n  ${ch.emoji} ${ch.name}`));
+			if (ch.setupSteps?.length) ch.setupSteps.forEach((s) => console.log(chalk.default.gray(`  ${s}`)));
+			else if (ch.tokenHint) console.log(chalk.default.gray(`  💡 ${ch.tokenHint}`));
+			const fields = [{
+				type: "password",
+				name: "token",
+				message: `${ch.tokenLabel}:`,
+				mask: "●"
+			}];
+			for (const f of ch.extraFields || []) fields.push({
+				type: "input",
+				name: f.name,
+				message: `${f.label}:${f.hint ? chalk.default.gray(` (${f.hint})`) : ""}`,
+				...f.required ? { validate: (v) => v.trim().length > 0 || `${f.label} is required` } : {}
+			});
+			channelConfigs[channelId] = await inquirer.default.prompt(fields);
+		}
+		if (selectedChannels.includes("twitch") && channelConfigs["twitch"]?.channels) {
+			const raw = channelConfigs["twitch"].channels;
+			channelConfigs["twitch"].channels = raw.split(",").map((s) => s.trim().replace(/^#/, "").toLowerCase()).filter(Boolean);
+		}
+		if (selectedChannels.includes("email")) {
+			const { wantGmailOAuth } = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "wantGmailOAuth",
+				message: "Enable Gmail OAuth for Pub/Sub real-time (send via hyperclaw gmail watch-setup)?",
+				default: false
+			}]);
+			if (wantGmailOAuth) {
+				console.log(chalk.default.gray("  Running OAuth flow for google-gmail..."));
+				try {
+					const { runOAuthFlow } = await Promise.resolve().then(() => require("./oauth-flow-DQPvMHRH.js"));
+					const { writeOAuthToken } = await Promise.resolve().then(() => require("./oauth-provider-Uo4Nib_c.js"));
+					const tokens = await runOAuthFlow("google-gmail", {});
+					const now = Math.floor(Date.now() / 1e3);
+					const expires_at = tokens.expires_in ? now + tokens.expires_in : void 0;
+					await writeOAuthToken("google-gmail", {
+						access_token: tokens.access_token,
+						refresh_token: tokens.refresh_token,
+						expires_at,
+						token_url: "https://oauth2.googleapis.com/token"
+					});
+					console.log(chalk.default.green("  ✔  Gmail OAuth configured — next: hyperclaw gmail watch-setup"));
+				} catch (e) {
+					console.log(chalk.default.yellow(`  ⚠  OAuth failed — you can run it later: hyperclaw auth oauth google-gmail`));
+				}
+			}
+		}
+		return channelConfigs;
+	}
+	async configureWebSearch(skip = false) {
+		if (skip) return null;
+		const { wantSearch } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantSearch",
+			message: "Configure a web search provider for the agent?",
+			default: false
+		}]);
+		if (!wantSearch) return null;
+		const SEARCH_PROVIDERS = [
+			{
+				id: "tavily",
+				name: "Tavily",
+				hint: "app.tavily.com — best for agents",
+				prefix: "tvly-"
+			},
+			{
+				id: "perplexity",
+				name: "Perplexity",
+				hint: "perplexity.ai/settings/api",
+				prefix: "pplx-"
+			},
+			{
+				id: "brave",
+				name: "Brave Search",
+				hint: "api.search.brave.com",
+				prefix: "BSA"
+			},
+			{
+				id: "gemini",
+				name: "Gemini",
+				hint: "aistudio.google.com/app/apikey",
+				prefix: "AIza"
+			},
+			{
+				id: "grok",
+				name: "Grok/xAI",
+				hint: "console.x.ai — same key as xAI provider",
+				prefix: "xai-"
+			},
+			{
+				id: "kimi",
+				name: "Kimi (Moonshot)",
+				hint: "platform.moonshot.cn/user-center/api-keys",
+				prefix: "sk-"
+			}
+		];
+		const { searchProvider } = await inquirer.default.prompt([{
+			type: "list",
+			name: "searchProvider",
+			message: "Select web search provider:",
+			choices: SEARCH_PROVIDERS.map((p) => ({
+				name: `${p.name.padEnd(14)} ${chalk.default.gray(p.hint)}`,
+				value: p.id
+			}))
+		}]);
+		const chosen = SEARCH_PROVIDERS.find((p) => p.id === searchProvider);
+		const { searchKey } = await inquirer.default.prompt([{
+			type: "password",
+			name: "searchKey",
+			message: `${chosen.name} API key (starts with ${chalk.default.gray(chosen.prefix)}):`,
+			mask: "●",
+			validate: (v) => v.trim().length > 4 || "Required"
+		}]);
+		console.log(chalk.default.green(`  ✔  Web search: ${chosen.name}`));
+		return {
+			provider: searchProvider,
+			apiKey: searchKey.trim()
+		};
+	}
+	async configureServiceApiKeys() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🔑 Service API Keys — any app with an API key\n"));
+		console.log(chalk.default.gray("  Stored securely in config. How they work:\n"));
+		console.log(chalk.default.gray("  • Wizard: add keys here\n"));
+		console.log(chalk.default.gray("  • Config: ~/.hyperclaw/hyperclaw.json → skills.apiKeys\n"));
+		console.log(chalk.default.gray("  • Env: HACKERONE_*, BUGCROWD_*, SYNACK_*, or CUSTOM_ID_API_KEY\n"));
+		console.log(chalk.default.gray("  • Tools: built-in tools read them automatically for research.\n"));
+		const { wantServiceKeys } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantServiceKeys",
+			message: "Add API keys for external services (HackerOne, Bugcrowd, Synack, or custom)?",
+			default: false
+		}]);
+		if (!wantServiceKeys) return {};
+		const KNOWN_SERVICES = [
+			{
+				id: "hackerone",
+				name: "HackerOne",
+				hint: "username:token (Basic auth)"
+			},
+			{
+				id: "bugcrowd",
+				name: "Bugcrowd",
+				hint: "Token from Bugcrowd API Credentials"
+			},
+			{
+				id: "synack",
+				name: "Synack",
+				hint: "API token from Synack"
+			},
+			{
+				id: "__custom__",
+				name: "Other (custom)",
+				hint: "Any app with an API key"
+			}
+		];
+		const { servicesToAdd } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "servicesToAdd",
+			message: "Select services:",
+			choices: KNOWN_SERVICES.filter((s) => s.id !== "__custom__").map((s) => ({
+				name: `${s.name}  ${chalk.default.gray(`(${s.hint})`)}`,
+				value: s.id
+			})),
+			validate: (v) => true
+		}]);
+		const apiKeys = {};
+		for (const sid of servicesToAdd || []) {
+			const svc = KNOWN_SERVICES.find((s) => s.id === sid);
+			const r = await inquirer.default.prompt([{
+				type: "password",
+				name: "key",
+				message: `${svc?.name || sid} API key:`,
+				mask: "●",
+				validate: (v) => v.trim().length > 3 || "Required"
+			}]);
+			apiKeys[sid] = r.key.trim();
+		}
+		const { addCustom } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "addCustom",
+			message: "Add a custom service (any app)?",
+			default: false
+		}]);
+		if (addCustom) {
+			const { customId, customKey } = await inquirer.default.prompt([{
+				type: "input",
+				name: "customId",
+				message: "Service ID (e.g. my-app, ads-power):",
+				validate: (v) => /^[a-z0-9_-]+$/i.test(v?.trim() || "") || "Letters, numbers, - _ only"
+			}, {
+				type: "password",
+				name: "customKey",
+				message: "API key:",
+				mask: "●",
+				validate: (v) => v.trim().length > 3 || "Required"
+			}]);
+			apiKeys[customId.trim().toLowerCase()] = customKey.trim();
+		}
+		if (Object.keys(apiKeys).length > 0) console.log(chalk.default.green(`  ✔  Saved ${Object.keys(apiKeys).length} API key(s)`));
+		return apiKeys;
+	}
+	async configureHyperClawBot(gatewayConfig) {
+		console.log(chalk.default.hex("#06b6d4")("\n  🤖 HyperClaw Bot — Remote control via Telegram\n"));
+		const trans = getTranscriptionProviders();
+		if (trans.length > 0) {
+			console.log(chalk.default.gray("  🎤 Voice notes: " + trans.map((p) => `${p.displayName}`).join(", ") + " — if you have their API key, voice messages will be transcribed to text."));
+			console.log();
+		}
+		const { wantHyperClawBot } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantHyperClawBot",
+			message: "Enable HyperClaw Bot for remote control (status, restart, /agent from mobile)?",
+			default: false
+		}]);
+		if (!wantHyperClawBot) return void 0;
+		const { token } = await inquirer.default.prompt([{
+			type: "input",
+			name: "token",
+			message: "Telegram Bot token (from @BotFather):",
+			validate: (v) => v.trim().length > 10 || "Required"
+		}]);
+		const { userIds } = await inquirer.default.prompt([{
+			type: "input",
+			name: "userIds",
+			message: "Allowed user IDs (comma-separated, leave empty = everyone):",
+			default: ""
+		}]);
+		const gatewayUrl = `http://localhost:${gatewayConfig?.port || 18789}`;
+		const { saveBotConfig } = await Promise.resolve().then(() => require("./hyperclawbot-zvczQgKx.js"));
+		await saveBotConfig({
+			platform: "telegram",
+			token: token.trim(),
+			gatewayUrl,
+			allowedUsers: userIds ? userIds.split(",").map((s) => s.trim()).filter(Boolean) : [],
+			gatewayToken: void 0,
+			enabled: true,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		console.log(chalk.default.green("  ✔  HyperClaw Bot configured — Start: hyperclaw bot start"));
+		return { token: token.trim() };
+	}
+	async configureTalkMode() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🎙️  Talk Mode — ElevenLabs TTS\n"));
+		const { wantTalkMode } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantTalkMode",
+			message: "Enable Talk Mode (voice responses via ElevenLabs)?",
+			default: false
+		}]);
+		if (!wantTalkMode) return void 0;
+		const { apiKey } = await inquirer.default.prompt([{
+			type: "password",
+			name: "apiKey",
+			message: "ElevenLabs API key (elevenlabs.io):",
+			mask: "●",
+			validate: (v) => v.trim().length > 10 || "Required"
+		}]);
+		console.log(chalk.default.green("  ✔  Talk Mode configured"));
+		return {
+			apiKey: apiKey.trim(),
+			voiceId: "21m00Tcm4TlvDq8ikWAM",
+			modelId: "eleven_multilingual_v2"
+		};
+	}
+	async configureMemoryIntegration() {
+		console.log(chalk.default.hex("#06b6d4")("\n  📂 Memory Integration (Obsidian / Raycast / Hazel)\n"));
+		const { vaultPath } = await inquirer.default.prompt([{
+			type: "input",
+			name: "vaultPath",
+			message: "Sync memory to vault? Enter path or leave empty to skip:",
+			default: ""
+		}]);
+		const vaultDir = String(vaultPath || "").trim();
+		if (!vaultDir) return void 0;
+		const { dailyNotes } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "dailyNotes",
+			message: "Write daily notes with session summaries?",
+			default: true
+		}]);
+		return {
+			vaultDir,
+			dailyNotes,
+			syncOnAppend: true
+		};
+	}
+	async configureIdentity() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🦅 Agent Identity\n"));
+		const identity = await inquirer.default.prompt([
+			{
+				type: "input",
+				name: "userName",
+				message: "Your name:",
+				default: "Boss"
+			},
+			{
+				type: "input",
+				name: "agentName",
+				message: "Agent name:",
+				default: "Hyper"
+			},
+			{
+				type: "input",
+				name: "wakeWord",
+				message: "Wake word for voice:",
+				default: (a) => `Hey ${a.agentName || "Hyper"}`
+			},
+			{
+				type: "list",
+				name: "personality",
+				message: "Personality:",
+				choices: [
+					"Professional and concise",
+					"Friendly and casual",
+					"Witty with humor",
+					"Direct and no-nonsense",
+					"Custom"
+				]
+			},
+			{
+				type: "input",
+				name: "customPersonality",
+				message: "Describe personality:",
+				when: (a) => a.personality === "Custom"
+			},
+			{
+				type: "list",
+				name: "language",
+				message: "Primary language:",
+				choices: [
+					"English",
+					"Greek",
+					"Spanish",
+					"French",
+					"German",
+					"Chinese",
+					"Japanese",
+					"Arabic"
+				]
+			}
+		]);
+		console.log(chalk.default.gray("\n  This is the greeting sent to your channels when the agent starts.\n"));
+		const { wakeUpMessage } = await inquirer.default.prompt([{
+			type: "input",
+			name: "wakeUpMessage",
+			message: "Agent wake-up message:",
+			default: (identity.agentName || "Hyper") + " is online. How can I help you today?"
+		}]);
+		const { wantSystemPrompt } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantSystemPrompt",
+			message: "Add a custom system prompt / instructions for the agent?",
+			default: false
+		}]);
+		let systemPrompt = "";
+		if (wantSystemPrompt) {
+			console.log(chalk.default.gray("  Tip: describe role, restrictions, tone, specific knowledge, etc.\n"));
+			const r = await inquirer.default.prompt([{
+				type: "editor",
+				name: "systemPrompt",
+				message: "System prompt (opens editor — save & close to continue):"
+			}]);
+			systemPrompt = r.systemPrompt?.trim() || "";
+		}
+		const globalRules = [
+			"Always respond in the user's preferred language",
+			"Never reveal the gateway auth token or API keys",
+			"Confirm before destructive or irreversible actions",
+			"Respect user privacy — never share conversation data",
+			"All subagents inherit these rules — cannot be overridden"
+		];
+		const { addRules } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "addRules",
+			message: "Add custom rules to AGENTS.md?",
+			default: false
+		}]);
+		let customRules = [];
+		if (addRules) {
+			const { rules } = await inquirer.default.prompt([{
+				type: "input",
+				name: "rules",
+				message: "Rules (semicolon-separated):",
+				filter: (v) => v.split(";").map((r) => r.trim()).filter(Boolean)
+			}]);
+			customRules = rules;
+		}
+		const personality = identity.personality === "Custom" ? identity.customPersonality || "Custom" : identity.personality;
+		return {
+			agentName: identity.agentName,
+			userName: identity.userName,
+			language: identity.language,
+			personality,
+			wakeUpMessage: wakeUpMessage.trim(),
+			systemPrompt: systemPrompt || void 0,
+			rules: [...globalRules, ...customRules]
+		};
+	}
+	async configureSkillsAndHooks() {
+		const { wantSkills } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantSkills",
+			message: "Configure skills & hooks now?",
+			default: false
+		}]);
+		if (!wantSkills) {
+			console.log(chalk.default.gray("  ↳ Skipped — enable later: hyperclaw hooks enable <name>\n"));
+			return {
+				hooks: [],
+				heartbeat: false
+			};
+		}
+		const { selectedHooks } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "selectedHooks",
+			message: "Select hooks to enable:",
+			choices: [
+				{
+					name: `${"boot.md".padEnd(22)} ${chalk.default.gray("Run commands on agent startup")}`,
+					value: "boot"
+				},
+				{
+					name: `${"command-logger".padEnd(22)} ${chalk.default.gray("Log every tool call to file")}`,
+					value: "command-logger"
+				},
+				{
+					name: `${"session-memory".padEnd(22)} ${chalk.default.gray("Persist session context across restarts")}`,
+					value: "session-memory"
+				},
+				{
+					name: `${"morning-briefing".padEnd(22)} ${chalk.default.gray("Daily proactive summary to HEARTBEAT.md")}`,
+					value: "morning-briefing"
+				}
+			]
+		}]);
+		const heartbeat = selectedHooks.includes("morning-briefing");
+		try {
+			const { HookLoader } = await Promise.resolve().then(() => require("./loader-CC45xGpC.js"));
+			const loader = new HookLoader();
+			for (const h of selectedHooks) loader.enable(h);
+		} catch {}
+		if (selectedHooks.length > 0) console.log(chalk.default.green(`  ✔ Enabled: ${selectedHooks.join(", ")}\n`));
+		return {
+			hooks: selectedHooks,
+			heartbeat
+		};
+	}
+	async configurePcAccess() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🔐 PC Access Level\n"));
+		console.log(chalk.default.gray("  Controls what the agent can do on your computer.\n"));
+		const { level } = await inquirer.default.prompt([{
+			type: "list",
+			name: "level",
+			message: "PC access level:",
+			choices: [
+				{
+					name: `Full        ${chalk.default.gray("(bash, file read/write, screenshots — recommended for power users)")}`,
+					value: "full"
+				},
+				{
+					name: `Sandboxed   ${chalk.default.gray("(read files, limited shell, no destructive writes)")}`,
+					value: "sandboxed"
+				},
+				{
+					name: `Read-only   ${chalk.default.gray("(read files only — safest)")}`,
+					value: "read-only"
+				}
+			],
+			default: "full"
+		}]);
+		const { confirmDestructive } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "confirmDestructive",
+			message: "Require confirmation before destructive actions (delete files, overwrite)?",
+			default: level !== "full"
+		}]);
+		console.log(chalk.default.green(`  ✔ PC access: ${level}${confirmDestructive ? " + confirm destructive" : ""}\n`));
+		return {
+			level,
+			confirmDestructive
+		};
+	}
+	async configureSkillHub() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🏪 Skill Hub (ClawHub)\n"));
+		console.log(chalk.default.gray("  Install skills from the ClawHub marketplace (AI tools, workflows, integrations).\n"));
+		const { wantSkills } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantSkills",
+			message: "Install skills from the Skill Hub?",
+			default: false
+		}]);
+		if (!wantSkills) return;
+		try {
+			const { SkillHub } = await Promise.resolve().then(() => require("./hub-LiD5Iztb.js"));
+			const hub = new SkillHub();
+			const FEATURED = [
+				{
+					name: `web-search       ${chalk.default.gray("(Google/Bing/DuckDuckGo search)")}`,
+					value: "web-search"
+				},
+				{
+					name: `file-manager     ${chalk.default.gray("(read, write, list files)")}`,
+					value: "file-manager"
+				},
+				{
+					name: `code-runner      ${chalk.default.gray("(run Python/JS snippets safely)")}`,
+					value: "code-runner"
+				},
+				{
+					name: `github-tools     ${chalk.default.gray("(repos, issues, PRs via API)")}`,
+					value: "github-tools"
+				},
+				{
+					name: `calendar-tools   ${chalk.default.gray("(Google Calendar read/write)")}`,
+					value: "calendar-tools"
+				},
+				{
+					name: `summarizer       ${chalk.default.gray("(summarize URLs, PDFs, text)")}`,
+					value: "summarizer"
+				},
+				{
+					name: `custom           ${chalk.default.gray("(enter skill ID manually)")}`,
+					value: "__custom__"
+				}
+			];
+			const { selectedSkills } = await inquirer.default.prompt([{
+				type: "checkbox",
+				name: "selectedSkills",
+				message: "Select skills to install:",
+				choices: FEATURED
+			}]);
+			for (const skillId of selectedSkills) if (skillId === "__custom__") {
+				const { customId } = await inquirer.default.prompt([{
+					type: "input",
+					name: "customId",
+					message: "  Skill ID from ClawHub:",
+					validate: (v) => v.trim().length > 0 || "Required"
+				}]);
+				if (customId.trim()) {
+					const s = (0, ora.default)(`Installing ${customId.trim()}...`).start();
+					try {
+						await hub.install(customId.trim(), false);
+						s.succeed(`Installed: ${customId.trim()}`);
+					} catch (e) {
+						s.fail(e.message);
+					}
+				}
+			} else {
+				const s = (0, ora.default)(`Installing ${skillId}...`).start();
+				try {
+					await hub.install(skillId, false);
+					s.succeed(`Installed: ${skillId}`);
+				} catch (e) {
+					s.warn(`${skillId}: ${e.message} (install later: hyperclaw skill install ${skillId})`);
+				}
+			}
+			if (selectedSkills.length > 0) console.log();
+		} catch {
+			console.log(chalk.default.yellow(`  ⚠ Skill Hub unavailable — install later: hyperclaw hub\n`));
+		}
+	}
+	async configureRateLimiting() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🚦 Rate Limiting\n"));
+		console.log(chalk.default.gray("  Limit how many messages the agent processes per channel per minute/hour.\n"));
+		const { wantRateLimit } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantRateLimit",
+			message: "Configure rate limits?",
+			default: false
+		}]);
+		if (!wantRateLimit) return void 0;
+		const { maxPerMinute, maxPerHour } = await inquirer.default.prompt([{
+			type: "input",
+			name: "maxPerMinute",
+			message: "  Max messages per minute per user (0 = unlimited):",
+			default: "0",
+			validate: (v) => !isNaN(Number(v)) || "Enter a number"
+		}, {
+			type: "input",
+			name: "maxPerHour",
+			message: "  Max messages per hour per user (0 = unlimited):",
+			default: "0",
+			validate: (v) => !isNaN(Number(v)) || "Enter a number"
+		}]);
+		const mpm = Number(maxPerMinute);
+		const mph = Number(maxPerHour);
+		if (mpm === 0 && mph === 0) return void 0;
+		console.log(chalk.default.green(`  ✔ Rate limit: ${mpm > 0 ? `${mpm}/min` : ""}${mpm > 0 && mph > 0 ? ", " : ""}${mph > 0 ? `${mph}/hr` : ""}\n`));
+		return {
+			...mpm > 0 ? { maxPerMinute: mpm } : {},
+			...mph > 0 ? { maxPerHour: mph } : {}
+		};
+	}
+	async configureDeveloperKey() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🔑 Developer API Key\n"));
+		console.log(chalk.default.gray("  Create a key for embedding HyperClaw in apps or managed hosting.\n"));
+		const { wantDevKey } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantDevKey",
+			message: "Create a developer API key?",
+			default: false
+		}]);
+		if (!wantDevKey) return;
+		try {
+			const developerKeys = await Promise.resolve().then(() => require("./developer-keys-CPWT7Q6S.js"));
+			const { name } = await inquirer.default.prompt([{
+				type: "input",
+				name: "name",
+				message: "  Key name:",
+				default: "default"
+			}]);
+			const { id, key } = await developerKeys.createDeveloperKey(name.trim() || "default");
+			console.log(chalk.default.green(`  ✔ Developer key created`));
+			console.log(chalk.default.gray(`  ID:  ${id}`));
+			console.log(chalk.default.yellow(`  Key: ${key}`));
+			console.log(chalk.default.gray(`  Store securely — shown once. Use: Authorization: Bearer <key>\n`));
+		} catch {
+			console.log(chalk.default.yellow(`  ⚠ Could not create key — run: hyperclaw developer-key create\n`));
+		}
+	}
+	async configureVoiceCall() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🎙️  Voice Call\n"));
+		console.log(chalk.default.gray("  Terminal voice call mode — speaks directly to the gateway.\n"));
+		const { wantVoiceCall } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantVoiceCall",
+			message: "Configure voice call settings?",
+			default: false
+		}]);
+		if (!wantVoiceCall) return;
+		const { gatewayUrl } = await inquirer.default.prompt([{
+			type: "input",
+			name: "gatewayUrl",
+			message: "  Gateway URL for voice calls:",
+			default: "http://localhost:18789"
+		}]);
+		const cfg = await this.config.load();
+		await this.config.patch({ channelConfigs: {
+			...cfg.channelConfigs || {},
+			"voice-call": { gatewayUrl: gatewayUrl.trim() }
+		} });
+		console.log(chalk.default.green(`  ✔ Voice call: ${gatewayUrl.trim()}\n`));
+		console.log(chalk.default.gray(`  Start: hyperclaw voice-call --gateway-url ${gatewayUrl.trim()}\n`));
+	}
+	async configureCanvas() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🎨 Canvas (AI-driven UI)\n"));
+		console.log(chalk.default.gray("  Live canvas for displaying AI-generated cards, charts, and components.\n"));
+		const { wantCanvas } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantCanvas",
+			message: "Enable canvas features?",
+			default: false
+		}]);
+		if (!wantCanvas) return;
+		const { canvasMode } = await inquirer.default.prompt([{
+			type: "list",
+			name: "canvasMode",
+			message: "  Default canvas mode:",
+			choices: [
+				{
+					name: `Auto    ${chalk.default.gray("(show canvas when AI generates structured output)")}`,
+					value: "auto"
+				},
+				{
+					name: `Always  ${chalk.default.gray("(always show canvas panel)")}`,
+					value: "always"
+				},
+				{
+					name: `Manual  ${chalk.default.gray("(show only via hyperclaw canvas show)")}`,
+					value: "manual"
+				}
+			],
+			default: "auto"
+		}]);
+		await this.config.patch({ channelConfigs: {
+			...(await this.config.load()).channelConfigs || {},
+			canvas: { mode: canvasMode }
+		} });
+		console.log(chalk.default.green(`  ✔ Canvas mode: ${canvasMode}\n`));
+	}
+	async configureDeploy() {
+		console.log(chalk.default.hex("#06b6d4")("\n  ☁️  Cloud Deploy\n"));
+		console.log(chalk.default.gray("  Deploy the gateway to a cloud platform (Fly.io or Render).\n"));
+		const { wantDeploy } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantDeploy",
+			message: "Set up cloud deployment?",
+			default: false
+		}]);
+		if (!wantDeploy) return;
+		const { platform } = await inquirer.default.prompt([{
+			type: "list",
+			name: "platform",
+			message: "  Platform:",
+			choices: [{
+				name: `Fly.io   ${chalk.default.gray("(recommended — fast global edge)")}`,
+				value: "fly"
+			}, {
+				name: `Render   ${chalk.default.gray("(free tier available — GitHub integration)")}`,
+				value: "render"
+			}]
+		}]);
+		if (platform === "fly") {
+			console.log(chalk.default.gray("\n  Fly.io deployment steps:"));
+			console.log(chalk.default.gray("  1. Install: curl -L https://fly.io/install.sh | sh"));
+			console.log(chalk.default.gray("  2. Login:   fly auth login"));
+			console.log(chalk.default.gray("  3. Launch:  fly launch"));
+			console.log(chalk.default.gray("  4. Secrets: fly secrets set ANTHROPIC_API_KEY=... HYPERCLAW_GATEWAY_TOKEN=..."));
+			console.log(chalk.default.gray("  5. Deploy:  fly deploy"));
+			console.log(chalk.default.gray("\n  Or: hyperclaw deploy --platform fly\n"));
+		} else {
+			console.log(chalk.default.gray("\n  Render deployment steps:"));
+			console.log(chalk.default.gray("  1. Push to GitHub"));
+			console.log(chalk.default.gray("  2. Connect at https://render.com → New Web Service → select repo"));
+			console.log(chalk.default.gray("  3. Set env: ANTHROPIC_API_KEY, HYPERCLAW_GATEWAY_TOKEN"));
+			console.log(chalk.default.gray("\n  Or: hyperclaw deploy --platform render\n"));
+		}
+		await this.config.patch({ channelConfigs: {
+			...(await this.config.load()).channelConfigs || {},
+			deploy: { platform }
+		} });
+		console.log(chalk.default.green(`  ✔ Deploy target saved: ${platform}\n`));
+	}
+	async configureMcpServers() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🔌 MCP Servers (Model Context Protocol)\n"));
+		console.log(chalk.default.gray("  Register external tool servers the agent can call (filesystem, browser, APIs).\n"));
+		const { wantMcp } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantMcp",
+			message: "Add MCP servers now?",
+			default: false
+		}]);
+		if (!wantMcp) return;
+		const { mcpAdd } = await Promise.resolve().then(() => require("./mcp-CfoSU4Uz.js"));
+		let addMore = true;
+		while (addMore) {
+			await mcpAdd();
+			const { more } = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "more",
+				message: "  Add another MCP server?",
+				default: false
+			}]);
+			addMore = more;
+		}
+	}
+	async configureWorkspaceTemplate() {
+		console.log(chalk.default.hex("#06b6d4")("\n  📁 Workspace Template\n"));
+		console.log(chalk.default.gray("  Initialize workspace files (SOUL.md, USER.md, TOOLS.md, HEARTBEAT.md).\n"));
+		const { wantTemplate } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantTemplate",
+			message: "Initialize workspace template files now?",
+			default: false
+		}]);
+		if (!wantTemplate) return;
+		const { selectedFiles } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "selectedFiles",
+			message: "Select template files to create:",
+			choices: [
+				{
+					name: `SOUL.md        ${chalk.default.gray("Agent core values, purpose & boundaries")}`,
+					value: "SOUL",
+					checked: true
+				},
+				{
+					name: `USER.md        ${chalk.default.gray("User profile, preferences & context")}`,
+					value: "USER",
+					checked: true
+				},
+				{
+					name: `TOOLS.md       ${chalk.default.gray("Tool inventory & usage guidelines")}`,
+					value: "TOOLS",
+					checked: false
+				},
+				{
+					name: `HEARTBEAT.md   ${chalk.default.gray("Daily status / morning briefing target")}`,
+					value: "HEARTBEAT",
+					checked: false
+				},
+				{
+					name: `AGENTS.md      ${chalk.default.gray("Rules & subagent configuration")}`,
+					value: "AGENTS",
+					checked: false
+				}
+			]
+		}]);
+		if (selectedFiles.length > 0) try {
+			const { initWorkspaceFiles } = await Promise.resolve().then(() => require("./memory-BlHL7JCO.js"));
+			const os$4 = (await import("os")).default;
+			const path$3 = (await import("path")).default;
+			const targetDir = path$3.join(os$4.homedir(), ".hyperclaw");
+			await initWorkspaceFiles({
+				agentName: "Hyper",
+				personality: "helpful and concise",
+				language: "English",
+				userName: "User",
+				rules: []
+			}, targetDir);
+			console.log(chalk.default.green(`  ✔ Workspace files initialized in ${targetDir}\n`));
+		} catch {
+			console.log(chalk.default.yellow(`  ⚠ Could not initialize workspace — run: hyperclaw workspace init\n`));
+		}
+	}
+	async configureCronTasks() {
+		console.log(chalk.default.hex("#06b6d4")("\n  ⏰ Scheduled Tasks (Cron)\n"));
+		console.log(chalk.default.gray("  Schedule recurring agent prompts (e.g. daily briefing, weekly report).\n"));
+		const PRESETS = [
+			{
+				name: `Morning briefing  ${chalk.default.gray("(Mon-Fri 9am)")}`,
+				schedule: "0 9 * * 1-5",
+				prompt: "Give me a morning briefing: check calendar, news, tasks."
+			},
+			{
+				name: `Daily summary     ${chalk.default.gray("(daily 6pm)")}`,
+				schedule: "0 18 * * *",
+				prompt: "Summarize today's activity and pending tasks."
+			},
+			{
+				name: `Weekly report     ${chalk.default.gray("(Mon 8am)")}`,
+				schedule: "0 8 * * 1",
+				prompt: "Generate a weekly summary of completed tasks and goals."
+			},
+			{
+				name: `Custom            ${chalk.default.gray("(enter manually)")}`,
+				schedule: "__custom__",
+				prompt: ""
+			}
+		];
+		const { wantCron } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantCron",
+			message: "Add scheduled tasks?",
+			default: false
+		}]);
+		if (!wantCron) return;
+		const { selectedPresets } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "selectedPresets",
+			message: "Select tasks to schedule:",
+			choices: PRESETS.map((p) => ({
+				name: p.name,
+				value: p.schedule
+			}))
+		}]);
+		const tasksToAdd = [];
+		for (const sch of selectedPresets) if (sch === "__custom__") {
+			const r = await inquirer.default.prompt([
+				{
+					type: "input",
+					name: "schedule",
+					message: "  Cron schedule (e.g. \"0 9 * * 1-5\"):",
+					validate: (v) => v.trim().length > 0 || "Required"
+				},
+				{
+					type: "input",
+					name: "prompt",
+					message: "  Agent prompt:",
+					validate: (v) => v.trim().length > 0 || "Required"
+				},
+				{
+					type: "input",
+					name: "name",
+					message: "  Task name:",
+					default: "Custom task"
+				}
+			]);
+			tasksToAdd.push({
+				schedule: r.schedule.trim(),
+				prompt: r.prompt.trim(),
+				name: r.name.trim()
+			});
+		} else {
+			const preset = PRESETS.find((p) => p.schedule === sch);
+			tasksToAdd.push({
+				schedule: preset.schedule,
+				prompt: preset.prompt,
+				name: preset.name.replace(/\s+\(.*\)/, "").trim()
+			});
+		}
+		if (tasksToAdd.length > 0) try {
+			const { loadCronTasks, addCronTask, saveCronTasks } = await Promise.resolve().then(() => require("./cron-tasks-Bli7Kzd2.js"));
+			await loadCronTasks();
+			for (const t of tasksToAdd) addCronTask(t.schedule, t.prompt, t.name);
+			await saveCronTasks();
+			console.log(chalk.default.green(`  ✔ ${tasksToAdd.length} task(s) scheduled\n`));
+		} catch {
+			console.log(chalk.default.yellow(`  ⚠ Could not save tasks — run: hyperclaw cron add\n`));
+		}
+	}
+	async configureAutoReply() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🔁 Auto-reply Rules\n"));
+		console.log(chalk.default.gray("  Automatic responses before the AI model is invoked.\n"));
+		const { wantAutoReply } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantAutoReply",
+			message: "Set up auto-reply rules?",
+			default: false
+		}]);
+		if (!wantAutoReply) return;
+		const PRESETS = [
+			{
+				name: `Away message   ${chalk.default.gray("(reply to every message when offline)")}`,
+				value: "away"
+			},
+			{
+				name: `Keyword reply  ${chalk.default.gray("(reply to specific keyword)")}`,
+				value: "keyword"
+			},
+			{
+				name: `Ignore channel ${chalk.default.gray("(silently ignore a channel)")}`,
+				value: "ignore"
+			}
+		];
+		const { ruleType } = await inquirer.default.prompt([{
+			type: "list",
+			name: "ruleType",
+			message: "Rule type:",
+			choices: PRESETS
+		}]);
+		try {
+			const { AutoReplyEngine } = await Promise.resolve().then(() => require("./rules-BE4GV6cV.js"));
+			const engine = new AutoReplyEngine();
+			await engine.load();
+			const BASE = {
+				enabled: true,
+				priority: 10,
+				stopOnMatch: true,
+				conditionLogic: "OR"
+			};
+			if (ruleType === "away") {
+				const { reply } = await inquirer.default.prompt([{
+					type: "input",
+					name: "reply",
+					message: "  Away message text:",
+					default: "I'm currently unavailable. I'll get back to you soon.",
+					validate: (v) => v.trim().length > 0 || "Required"
+				}]);
+				await engine.add({
+					...BASE,
+					name: "Away message",
+					conditions: [{ type: "always" }],
+					action: {
+						type: "reply",
+						reply: reply.trim()
+					}
+				});
+			} else if (ruleType === "keyword") {
+				const r = await inquirer.default.prompt([{
+					type: "input",
+					name: "keyword",
+					message: "  Trigger keyword:",
+					validate: (v) => v.trim().length > 0 || "Required"
+				}, {
+					type: "input",
+					name: "reply",
+					message: "  Reply text:",
+					validate: (v) => v.trim().length > 0 || "Required"
+				}]);
+				await engine.add({
+					...BASE,
+					name: `Keyword: ${r.keyword}`,
+					conditions: [{
+						type: "contains",
+						value: r.keyword.trim()
+					}],
+					action: {
+						type: "reply",
+						reply: r.reply.trim()
+					}
+				});
+			} else if (ruleType === "ignore") {
+				const { channelId } = await inquirer.default.prompt([{
+					type: "input",
+					name: "channelId",
+					message: "  Channel ID to ignore:",
+					validate: (v) => v.trim().length > 0 || "Required"
+				}]);
+				await engine.add({
+					...BASE,
+					name: `Ignore channel: ${channelId}`,
+					conditions: [{
+						type: "channel",
+						value: channelId.trim()
+					}],
+					action: { type: "ignore" }
+				});
+			}
+			console.log(chalk.default.green(`  ✔ Auto-reply rule added\n`));
+		} catch {
+			console.log(chalk.default.yellow(`  ⚠ Could not save rule — run: hyperclaw auto-reply list\n`));
+		}
+	}
+	async configureWebhooks() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🔗 Inbound Webhooks\n"));
+		console.log(chalk.default.gray("  Register POST endpoints that trigger the agent (GitHub, Stripe, Linear, etc).\n"));
+		const { wantWebhook } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantWebhook",
+			message: "Register inbound webhook endpoints?",
+			default: false
+		}]);
+		if (!wantWebhook) return;
+		try {
+			const { WebhookManager } = await Promise.resolve().then(() => require("./manager-BpDfbDjg.js"));
+			const manager = new WebhookManager();
+			await manager.load();
+			let addMore = true;
+			while (addMore) {
+				const r = await inquirer.default.prompt([
+					{
+						type: "input",
+						name: "name",
+						message: "  Webhook name (e.g. GitHub push):",
+						validate: (v) => v.trim().length > 0 || "Required"
+					},
+					{
+						type: "list",
+						name: "format",
+						message: "  Payload format:",
+						choices: [
+							{
+								name: "GitHub",
+								value: "github"
+							},
+							{
+								name: "Stripe",
+								value: "stripe"
+							},
+							{
+								name: "Linear",
+								value: "linear"
+							},
+							{
+								name: "Notion",
+								value: "notion"
+							},
+							{
+								name: "JSON (generic)",
+								value: "json"
+							},
+							{
+								name: "Raw",
+								value: "raw"
+							}
+						]
+					},
+					{
+						type: "input",
+						name: "template",
+						message: "  Message template (use {{body.field}}):",
+						default: "Webhook received: {{body}}"
+					}
+				]);
+				await manager.add({
+					name: r.name.trim(),
+					format: r.format,
+					template: r.template.trim(),
+					routeTo: {
+						type: "channel",
+						target: "default"
+					}
+				});
+				const { more } = await inquirer.default.prompt([{
+					type: "confirm",
+					name: "more",
+					message: "  Add another webhook?",
+					default: false
+				}]);
+				addMore = more;
+			}
+			console.log(chalk.default.green(`  ✔ Webhook(s) registered — route: POST /webhook/<id>\n`));
+		} catch {
+			console.log(chalk.default.yellow(`  ⚠ Could not save webhooks — run: hyperclaw webhooks list\n`));
+		}
+	}
+	async configureNodes() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🖥️  Nodes (Remote Compute / Mobile)\n"));
+		console.log(chalk.default.gray("  Add VPS, Raspberry Pi, Android, or VM nodes for distributed inference.\n"));
+		const { wantNode } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantNode",
+			message: "Add compute nodes?",
+			default: false
+		}]);
+		if (!wantNode) return;
+		const { nodeAdd } = await Promise.resolve().then(() => require("./node-Dw2Gi-cP.js"));
+		let addMore = true;
+		while (addMore) {
+			await nodeAdd();
+			const { more } = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "more",
+				message: "  Add another node?",
+				default: false
+			}]);
+			addMore = more;
+		}
+	}
+	async configureOAuth() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🔐 OAuth / External Auth\n"));
+		console.log(chalk.default.gray("  Connect Google, GitHub or other accounts for the agent to act on your behalf.\n"));
+		const { wantOAuth } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantOAuth",
+			message: "Set up OAuth / external auth now?",
+			default: false
+		}]);
+		if (!wantOAuth) return;
+		const { selectedProviders } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "selectedProviders",
+			message: "Select providers to connect:",
+			choices: [
+				{
+					name: `Google Calendar   ${chalk.default.gray("(read/create events)")}`,
+					value: "google-calendar"
+				},
+				{
+					name: `Google Drive      ${chalk.default.gray("(read/write files)")}`,
+					value: "google-drive"
+				},
+				{
+					name: `GitHub            ${chalk.default.gray("(repos, issues, PRs)")}`,
+					value: "github"
+				},
+				{
+					name: `Notion            ${chalk.default.gray("(pages & databases)")}`,
+					value: "notion"
+				},
+				{
+					name: `Linear            ${chalk.default.gray("(issues & projects)")}`,
+					value: "linear"
+				}
+			]
+		}]);
+		for (const provider of selectedProviders) {
+			console.log(chalk.default.gray(`\n  Starting OAuth flow for ${provider}...`));
+			try {
+				const { runOAuthFlow } = await Promise.resolve().then(() => require("./oauth-flow-DQPvMHRH.js"));
+				const { writeOAuthToken } = await Promise.resolve().then(() => require("./oauth-provider-Uo4Nib_c.js"));
+				const tokens = await runOAuthFlow(provider, {});
+				const now = Math.floor(Date.now() / 1e3);
+				await writeOAuthToken(provider, {
+					access_token: tokens.access_token,
+					refresh_token: tokens.refresh_token,
+					expires_at: tokens.expires_in ? now + tokens.expires_in : void 0,
+					token_url: `https://oauth2.googleapis.com/token`
+				});
+				console.log(chalk.default.green(`  ✔ ${provider} connected\n`));
+			} catch {
+				console.log(chalk.default.yellow(`  ⚠ ${provider} OAuth failed — run later: hyperclaw auth oauth ${provider}\n`));
+			}
+		}
+	}
+	async configureAgentBindings() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🤝 Multi-agent Bindings\n"));
+		console.log(chalk.default.gray("  Route specific channels to different agent personas or models.\n"));
+		const { wantBindings } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantBindings",
+			message: "Configure channel → agent bindings?",
+			default: false
+		}]);
+		if (!wantBindings) return;
+		try {
+			const { AgentRouter } = await Promise.resolve().then(() => require("./agents-routing-ChqZ6l2S.js"));
+			await new AgentRouter().bind();
+			return;
+		} catch {
+			const r = await inquirer.default.prompt([
+				{
+					type: "input",
+					name: "channel",
+					message: "  Channel ID (e.g. telegram):",
+					validate: (v) => v.trim().length > 0 || "Required"
+				},
+				{
+					type: "input",
+					name: "agentName",
+					message: "  Agent name / persona for this channel:",
+					default: "Hyper"
+				},
+				{
+					type: "input",
+					name: "modelId",
+					message: "  Override model ID (leave blank = use primary):",
+					default: ""
+				}
+			]);
+			if (r.channel) {
+				const fs$4 = (await import("fs-extra")).default;
+				const path$3 = (await import("path")).default;
+				const os$4 = (await import("os")).default;
+				const bindFile = path$3.join(os$4.homedir(), ".hyperclaw", "agent-bindings.json");
+				let bindings = [];
+				try {
+					bindings = await fs$4.readJson(bindFile);
+				} catch {}
+				bindings.push({
+					channelId: r.channel.trim(),
+					agentName: r.agentName.trim(),
+					modelId: r.modelId.trim() || void 0,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				await fs$4.ensureDir(path$3.dirname(bindFile));
+				await fs$4.writeJson(bindFile, bindings, { spaces: 2 });
+				console.log(chalk.default.green(`  ✔ Binding: ${r.channel} → ${r.agentName}\n`));
+			}
+		}
+	}
+	async configureGroupSandbox() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🐳 Group Sandbox (Docker)\n"));
+		console.log(chalk.default.gray("  Isolates group chat sessions in Docker containers for security.\n"));
+		const { wantSandbox } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "wantSandbox",
+			message: "Enable Docker sandboxing for group chat sessions?",
+			default: false
+		}]);
+		if (!wantSandbox) return void 0;
+		const { image, memoryLimit } = await inquirer.default.prompt([{
+			type: "input",
+			name: "image",
+			message: "  Docker image:",
+			default: "node:22-alpine"
+		}, {
+			type: "input",
+			name: "memoryLimit",
+			message: "  Memory limit per container:",
+			default: "256m"
+		}]);
+		console.log(chalk.default.green(`  ✔ Group sandbox: ${image} (${memoryLimit})\n`));
+		return {
+			enabled: true,
+			image: image.trim(),
+			memoryLimit: memoryLimit.trim()
+		};
+	}
+	async configureUpdateChannel() {
+		console.log(chalk.default.hex("#06b6d4")("\n  🔄 Update Channel\n"));
+		const { channel } = await inquirer.default.prompt([{
+			type: "list",
+			name: "channel",
+			message: "Update channel:",
+			choices: [
+				{
+					name: `Stable  ${chalk.default.gray("(recommended — tested releases)")}`,
+					value: "stable"
+				},
+				{
+					name: `Beta    ${chalk.default.gray("(early access — new features, may have bugs)")}`,
+					value: "beta"
+				},
+				{
+					name: `Dev     ${chalk.default.gray("(bleeding edge — for contributors)")}`,
+					value: "dev"
+				}
+			],
+			default: "stable"
+		}]);
+		console.log(chalk.default.green(`  ✔ Update channel: ${channel}\n`));
+		return channel;
+	}
+	async saveAll(data, options) {
+		console.log();
+		const spinner = (0, ora.default)("Saving configuration...").start();
+		const current = await this.config.load();
+		const skillsPatch = { installed: current?.skills?.installed || [] };
+		if (data.serviceApiKeys && Object.keys(data.serviceApiKeys).length > 0) skillsPatch.apiKeys = {
+			...current?.skills?.apiKeys || {},
+			...data.serviceApiKeys
+		};
+		if (current?.skills?.vtApiKey) skillsPatch.vtApiKey = current.skills.vtApiKey;
+		const finalSkills = skillsPatch.apiKeys || skillsPatch.vtApiKey ? skillsPatch : current?.skills || { installed: [] };
+		await this.config.save({
+			...current,
+			version: "5.0.0",
+			workspaceName: data.workspaceName,
+			provider: data.providerConfig,
+			providers: data.providers || (data.providerConfig ? [data.providerConfig] : []),
+			gateway: data.gatewayConfig || void 0,
+			channels: Object.keys(data.channelConfigs || {}),
+			channelConfigs: data.channelConfigs,
+			skills: finalSkills,
+			enabledHooks: data.hooks || [],
+			identity: {
+				agentName: data.identity?.agentName,
+				userName: data.identity?.userName,
+				language: data.identity?.language,
+				wakeWord: data.identity?.wakeWord || `Hey ${data.identity?.agentName || "Hyper"}`,
+				wakeUpMessage: data.identity?.wakeUpMessage,
+				systemPrompt: data.identity?.systemPrompt,
+				personality: data.identity?.personality,
+				rules: data.identity?.rules
+			},
+			memoryIntegration: data.memoryIntegration,
+			talkMode: data.talkModeConfig,
+			pcAccess: {
+				enabled: true,
+				level: data.pcAccess?.level || "full",
+				allowedPaths: [],
+				allowedCommands: [],
+				confirmDestructive: data.pcAccess?.confirmDestructive ?? false,
+				maxOutputBytes: 5e4
+			},
+			updateChannel: data.updateChannel || "stable",
+			groupSandbox: data.groupSandbox,
+			...data.webSearch ? { webSearch: data.webSearch } : {},
+			...data.rateLimit ? { rateLimit: data.rateLimit } : {},
+			hatchMode: data.hatchMode || "tui",
+			installedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		spinner.succeed("Configuration saved");
+		const memory = new MemoryManager();
+		await memory.init(data.identity);
+		if (data.heartbeatEnabled) try {
+			const { HookLoader } = await Promise.resolve().then(() => require("./loader-CC45xGpC.js"));
+			const loader = new HookLoader();
+			loader.enable("morning-briefing");
+			console.log(chalk.default.gray("  ✔  Morning Briefing hook enabled"));
+		} catch {}
+		await this.testConnections(data.channelConfigs || {});
+		if (data.installDaemon || options.daemon || options.installDaemon) {
+			const runtime = options.daemonRuntime ?? data.daemonRuntime ?? "node";
+			const s = (0, ora.default)(`🩸 Installing system daemon (runtime: ${runtime})...`).start();
+			await this.daemon.install();
+			s.succeed(chalk.default.red(`🩸 System daemon installed (runtime: ${runtime}, starts on boot)`));
+		}
+		if (data.gatewayConfig?.tailscaleExposure && data.gatewayConfig.tailscaleExposure !== "off") await this.gateway.applyTailscaleExposure(data.gatewayConfig.tailscaleExposure, data.gatewayConfig.port);
+		if (data.gatewayConfig && (options.startNow || data.installDaemon)) {
+			const s = (0, ora.default)("Starting gateway...").start();
+			await this.daemon.start();
+			s.succeed(`Gateway running at ws://localhost:${data.gatewayConfig.port}`);
+		}
+		console.log(chalk.default.gray("\n  Running health check...\n"));
+		const healthResults = {};
+		try {
+			const { runDoctor } = await Promise.resolve().then(() => require("./doctor-CxyPLYsJ.js"));
+			await runDoctor(true);
+			healthResults.doctor = "ok";
+		} catch {
+			healthResults.doctor = "failed";
+		}
+		if (data.gatewayConfig && (options.startNow || data.installDaemon)) try {
+			const http = await import("http");
+			const port = data.gatewayConfig.port || 18789;
+			const reachable = await new Promise((resolve) => {
+				const req = http.get(`http://127.0.0.1:${port}/api/status`, () => resolve(true));
+				req.on("error", () => resolve(false));
+				req.setTimeout(3e3, () => {
+					req.destroy();
+					resolve(false);
+				});
+			});
+			healthResults.gateway = reachable ? "reachable" : "unreachable";
+			if (reachable) console.log(chalk.default.green(`  ✔  Gateway reachable at port ${port}`));
+			else console.log(chalk.default.yellow(`  ⚠  Gateway not yet reachable at port ${port} — it may still be starting`));
+		} catch {
+			healthResults.gateway = "error";
+		}
+		if (options.jsonOutput) {
+			const result = {
+				ok: true,
+				version: "5.0.0",
+				provider: data.providerConfig?.providerId,
+				model: data.providerConfig?.modelId,
+				gateway: data.gatewayConfig ? {
+					port: data.gatewayConfig.port,
+					bind: data.gatewayConfig.bind
+				} : null,
+				channels: Object.keys(data.channelConfigs || {}),
+				hooks: data.hooks || [],
+				daemonInstalled: !!(data.installDaemon || options.installDaemon),
+				health: healthResults
+			};
+			process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+			return;
+		}
+		this.showSuccessScreen(data);
+	}
+	async testConnections(configs) {
+		for (const [channelId, cfg] of Object.entries(configs)) {
+			const ch = CHANNELS.find((c) => c.id === channelId);
+			if (!ch || !cfg?.token) continue;
+			const s = (0, ora.default)(`Testing ${ch.name}...`).start();
+			await new Promise((r) => setTimeout(r, 900 + Math.random() * 600));
+			s.succeed(`${ch.emoji} ${ch.name} connected`);
+		}
+	}
+	showSuccessScreen(data) {
+		const channels = Object.keys(data.channelConfigs || {});
+		const gwUrl = `ws://localhost:${data.gatewayConfig?.port || 1515}`;
+		const hasEmail = channels.includes("email");
+		const hasHyperClawBot = !!data.hyperclawbotConfig?.token;
+		const cmdLines = [
+			chalk.default.gray("  hyperclaw dashboard       — TUI dashboard"),
+			chalk.default.gray("  hyperclaw hub             — Skill hub"),
+			chalk.default.gray("  hyperclaw gateway status  — Gateway panel"),
+			chalk.default.gray("  hyperclaw ") + chalk.default.red("daemon") + chalk.default.gray(" status   — Service status"),
+			chalk.default.gray("  hyperclaw voice           — Voice settings"),
+			chalk.default.gray("  hyperclaw canvas show     — AI canvas")
+		];
+		if (hasHyperClawBot) cmdLines.push(chalk.default.gray("  hyperclaw bot start        — HyperClawBot remote control"));
+		if (hasEmail) cmdLines.push(chalk.default.gray("  hyperclaw gmail watch-setup — Gmail Pub/Sub (real-time)"));
+		cmdLines.push(chalk.default.gray("  hyperclaw nodes             — Mobile nodes (Connect tab)"));
+		cmdLines.push(chalk.default.gray("  hyperclaw cron list         — Scheduled tasks"));
+		const lines = [
+			`${chalk.default.gray("Agent:")}     ${chalk.default.hex("#06b6d4")(data.identity?.agentName)} (you: ${data.identity?.userName})`,
+			`${chalk.default.gray("Model:")}     ${data.providerConfig?.modelId}`,
+			`${chalk.default.gray("Provider:")} ${data.providerConfig?.providerId}`,
+			`${chalk.default.gray("Gateway:")}  ${gwUrl}`,
+			`${chalk.default.gray("Channels:")} ${channels.length ? channels.join(", ") : "CLI only"}`,
+			"",
+			chalk.default.hex("#06b6d4")("Commands:"),
+			...cmdLines
+		].join("\n");
+		console.log("\n" + (0, boxen.default)(chalk.default.hex("#06b6d4")("🎉 HyperClaw v5.0.0 ready!\n\n") + lines, {
+			padding: 1,
+			borderStyle: "round",
+			borderColor: "cyan",
+			margin: 1,
+			backgroundColor: "#0a0a0a"
+		}));
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'Banner', {
+  enumerable: true,
+  get: function () {
+    return Banner;
+  }
+});
+Object.defineProperty(exports, 'ConfigStore', {
+  enumerable: true,
+  get: function () {
+    return ConfigStore;
+  }
+});
+Object.defineProperty(exports, 'GatewayManager', {
+  enumerable: true,
+  get: function () {
+    return GatewayManager;
+  }
+});
+Object.defineProperty(exports, 'HyperClawWizard', {
+  enumerable: true,
+  get: function () {
+    return HyperClawWizard;
+  }
+});