hyperclaw 5.3.3 → 5.3.45

package/dist/onboard-C7vJegQc.js

@@ -0,0 +1,3812 @@
+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_config = require('./config-DGAAJ49A.js');
+const require_daemon = require('./daemon-C4j0wqxz.js');
+const require_gateway = require('./gateway-CzI8dnlS.js');
+const require_providers = require('./providers-DP8T0QCR.js');
+const require_theme = require('./theme-CLXvI6Hr.js');
+const require_banner = require('./banner-DG3v43xA.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 https = require_chunk.__toESM(require("https"));
+
+//#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
+require_paths$1.init_paths();
+const getAgentsFile = () => path.default.join(require_paths.getHyperClawDir(), "AGENTS.md");
+const getMemoryFile = () => path.default.join(require_paths.getHyperClawDir(), "MEMORY.md");
+const getSoulFile = () => path.default.join(require_paths.getHyperClawDir(), "SOUL.md");
+const getLogDir = () => path.default.join(require_paths.getHyperClawDir(), "logs");
+var MemoryManager = class {
+	async init(opts = {}) {
+		await fs_extra.default.ensureDir(require_paths.getHyperClawDir());
+		await fs_extra.default.ensureDir(getLogDir());
+		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(getAgentsFile())) await fs_extra.default.writeFile(getAgentsFile(), `# 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
+
+## User prompt & skill integration
+- When the user provides a prompt, system instruction, or persona text in chat: integrate it into SOUL.md using create_memory_file (filename: SOUL.md).
+- When the user provides a skill definition or asks to add a skill: use the skill install tools (install from clawhub, paste content, or write_skill).
+`);
+		if (!await fs_extra.default.pathExists(getMemoryFile())) await fs_extra.default.writeFile(getMemoryFile(), `# 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(getSoulFile())) await fs_extra.default.writeFile(getSoulFile(), `# 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(getLogDir(), `${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(getAgentsFile())) return null;
+		const agents = await fs_extra.default.readFile(getAgentsFile(), "utf8").catch(() => "");
+		const memory = await fs_extra.default.readFile(getMemoryFile(), "utf8").catch(() => "");
+		const soul = await fs_extra.default.readFile(getSoulFile(), "utf8").catch(() => void 0);
+		return {
+			agents,
+			memory,
+			soul
+		};
+	}
+	async appendRule(rule) {
+		await fs_extra.default.ensureDir(require_paths.getHyperClawDir());
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const line = `\n- ${today}: ${rule}\n`;
+		await fs_extra.default.appendFile(getAgentsFile(), line);
+		console.log(chalk.default.green(`  ✅ Rule added to AGENTS.md: ${rule}`));
+	}
+	async addMemory(fact) {
+		await fs_extra.default.ensureDir(require_paths.getHyperClawDir());
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		await fs_extra.default.appendFile(getMemoryFile(), `\n- ${today}: ${fact}\n`);
+		console.log(chalk.default.green(`  ✅ Memory saved: ${fact}`));
+	}
+	async updateSoul(content) {
+		await fs_extra.default.ensureDir(require_paths.getHyperClawDir());
+		await fs_extra.default.writeFile(getSoulFile(), 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", getSoulFile()],
+			["AGENTS", getAgentsFile()],
+			["MEMORY", getMemoryFile()]
+		]) 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(getAgentsFile());
+			await fs_extra.default.remove(getMemoryFile());
+			await fs_extra.default.remove(getSoulFile());
+			console.log(chalk.default.green("  ✅ All memory cleared"));
+		} else {
+			await fs_extra.default.writeFile(getMemoryFile(), "# MEMORY.md\n\n");
+			console.log(chalk.default.green("  ✅ MEMORY.md cleared"));
+		}
+	}
+};
+
+//#endregion
+//#region src/cli/security.ts
+let _securityDisclaimerShown = false;
+async function showSecurityDisclaimer() {
+	if (_securityDisclaimerShown) return true;
+	_securityDisclaimerShown = true;
+	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: "list",
+		name: "understood",
+		message: chalk.default.bold("I understand this is powerful and inherently risky."),
+		choices: [{
+			name: chalk.default.green("Yes, continue  — I understand the risks"),
+			value: true
+		}, {
+			name: chalk.default.gray("No, exit       — I'll come back later"),
+			value: false
+		}],
+		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-B4vH02lO.js"));
+	const res = await cdmp(channelName);
+	return {
+		dmPolicy: res.policy,
+		allowFrom: res.allowFrom ?? []
+	};
+}
+
+//#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
+require_providers.init_providers();
+/** 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 require_config.ConfigStore();
+	daemon = new require_daemon.DaemonManager();
+	gateway = new require_gateway.GatewayManager();
+	async run(options) {
+		const existingCfg = await this.config.load();
+		const hasExistingConfig = !!(existingCfg && (existingCfg.provider || existingCfg.providers?.length));
+		if (hasExistingConfig && !options.nonInteractive) {
+			const { getConfigPath } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+			console.log(chalk.default.yellow(`\n  ⚠ Existing config detected: ${chalk.default.bold(getConfigPath())}\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.yellow("⚠")} 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$3 = await import("fs-extra");
+				const path$3 = await import("path");
+				const { getHyperClawDir: getHyperClawDir$1, getConfigPath: getConfigPath$1 } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+				const hcDir = getHyperClawDir$1();
+				const backupDir = path$3.join(hcDir, `backup-${Date.now()}`);
+				await fs$3.ensureDir(backupDir);
+				const toRemove = [getConfigPath$1()];
+				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$3.pathExists(f)) await fs$3.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-DdZT-Bq4.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 require_banner.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 } = (require_theme.init_theme(), require_chunk.__toCommonJS(require_theme.theme_exports));
+		const t = getTheme(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 = 8;
+		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, "Launch");
+		const launchChoices = [{
+			name: `${chalk.default.yellow("Hatch in TUI")} (recommended)  — terminal chat`,
+			value: "tui"
+		}];
+		if (gatewayConfig && !gatewayConfig.remote) launchChoices.push({
+			name: `${chalk.default.cyan("Open the Web UI")} — 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
+		}]);
+		let installDaemon = options.installDaemon ?? false;
+		let startNow = false;
+		if (!installDaemon) {
+			const { wantDaemon } = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "wantDaemon",
+				message: "Install as system daemon (auto-start on boot)?",
+				default: false
+			}]);
+			installDaemon = wantDaemon;
+		}
+		if (installDaemon || !Object.keys(channelConfigs).length) startNow = true;
+		else {
+			const { wantStart } = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "wantStart",
+				message: "Start the bot now? (Telegram/Discord will respond once running)",
+				default: true
+			}]);
+			startNow = wantStart;
+		}
+		this.stepHeader(8, STEPS, "Extras");
+		const { skipExtras } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "skipExtras",
+			message: "Skip optional extras for now? (web search, memory, services, etc. — configure later)",
+			default: true
+		}]);
+		let webSearch, memoryIntegration, serviceApiKeys, hyperclawbotConfig, talkModeConfig;
+		let pcAccess, updateChannel, groupSandbox, rateLimit;
+		if (!skipExtras) {
+			webSearch = await this.configureWebSearch(options.skipSearch);
+			memoryIntegration = await this.configureMemoryIntegration();
+			serviceApiKeys = await this.configureServiceApiKeys();
+			hyperclawbotConfig = await this.configureHyperClawBot(gatewayConfig, channelConfigs);
+			talkModeConfig = await this.configureTalkMode();
+			pcAccess = await this.configurePcAccess();
+			updateChannel = await this.configureUpdateChannel();
+			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();
+			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,
+			installDaemon,
+			startNow,
+			hatchMode
+		}, 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 { skipExtras } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "skipExtras",
+			message: "Skip optional extras for now? (web search, memory, services, etc. — configure later)",
+			default: true
+		}]);
+		let webSearch, memoryIntegration, serviceApiKeys, hyperclawbotConfig, talkModeConfig;
+		let pcAccess, updateChannel, groupSandbox, rateLimit;
+		if (!skipExtras) {
+			webSearch = await this.configureWebSearch(options.skipSearch);
+			memoryIntegration = await this.configureMemoryIntegration();
+			serviceApiKeys = await this.configureServiceApiKeys();
+			hyperclawbotConfig = await this.configureHyperClawBot(gatewayConfig, channelConfigs);
+			talkModeConfig = await this.configureTalkMode();
+			pcAccess = await this.configurePcAccess();
+			updateChannel = await this.configureUpdateChannel();
+			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();
+			rateLimit = await this.configureRateLimiting();
+			await this.configureDeveloperKey();
+			await this.configureVoiceCall();
+			await this.configureCanvas();
+			await this.configureDeploy();
+		}
+		this.stepHeader(9, STEPS, "Launch");
+		const launchChoices = [{
+			name: `${chalk.default.yellow("Hatch in TUI")} (recommended)  — terminal chat`,
+			value: "tui"
+		}];
+		if (gatewayConfig && !gatewayConfig.remote) launchChoices.push({
+			name: `${chalk.default.cyan("Open the Web UI")} — 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 } = (require_theme.init_theme(), require_chunk.__toCommonJS(require_theme.theme_exports));
+		const t = getTheme(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: require_providers.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 = require_providers.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$3 = await import("fs-extra");
+				const path$3 = await import("path");
+				const os$3 = await import("os");
+				const credPath = path$3.join(os$3.homedir(), ".claude", ".credentials.json");
+				const credExists = await fs$3.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 { validateApiKeyFormat } = await Promise.resolve().then(() => require("./api-key-validation-DgOBmp8Y.js"));
+				const r = await inquirer.default.prompt([{
+					type: "password",
+					name: "apiKey",
+					message: `  ${provider.authLabel}:`,
+					mask: "●",
+					validate: (v) => {
+						const t$1 = (v || "").trim();
+						if (t$1.length < 5) return "Required";
+						const err = validateApiKeyFormat(pid, t$1);
+						return err || true;
+					}
+				}]);
+				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: require_providers.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 or http://127.0.0.1:18789 for SSH tunnel):",
+				validate: (v) => v.startsWith("ws") || v.startsWith("http") || "Must start with ws://, wss:// or http://"
+			}]);
+			const { remoteToken } = await inquirer.default.prompt([{
+				type: "password",
+				name: "remoteToken",
+				message: "Remote gateway auth token:",
+				mask: "?"
+			}]);
+			const httpUrl = remoteUrl.startsWith("http") ? remoteUrl : remoteUrl.replace(/^ws/, "http");
+			console.log(chalk.default.green("  ✔ Remote gateway configured\n"));
+			return {
+				port: 18789,
+				bind: "127.0.0.1",
+				authToken: "",
+				tailscaleExposure: "off",
+				runtime: "node",
+				enabledChannels: [],
+				hooks: true,
+				mode: "remote",
+				remote: {
+					url: httpUrl,
+					token: remoteToken || void 0
+				}
+			};
+		}
+		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-BbLQTzZk.js"));
+					const { writeOAuthToken } = await Promise.resolve().then(() => require("./oauth-provider-UZyG84s7.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, existingChannelConfigs) {
+		console.log(chalk.default.hex("#06b6d4")("\n  🤖 HyperClaw Bot — Remote control via Telegram\n"));
+		const trans = require_providers.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 existingTelegramToken = existingChannelConfigs?.["telegram"]?.token;
+		let token;
+		if (existingTelegramToken) {
+			const { reuseToken } = await inquirer.default.prompt([{
+				type: "confirm",
+				name: "reuseToken",
+				message: "Use the same Telegram bot you already configured above?",
+				default: true
+			}]);
+			if (reuseToken) {
+				token = existingTelegramToken;
+				console.log(chalk.default.green("  ✔  Reusing existing Telegram bot token\n"));
+			} else {
+				const r = await inquirer.default.prompt([{
+					type: "input",
+					name: "token",
+					message: "Telegram Bot token (from @BotFather):",
+					validate: (v) => v.trim().length > 10 || "Required"
+				}]);
+				token = r.token.trim();
+			}
+		} else {
+			const r = await inquirer.default.prompt([{
+				type: "input",
+				name: "token",
+				message: "Telegram Bot token (from @BotFather):",
+				validate: (v) => v.trim().length > 10 || "Required"
+			}]);
+			token = r.token.trim();
+		}
+		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-DcQt62PL.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-Dq_cDlOW.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-BJM2KXLO.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-CzDxVczE.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-SsMEvl28.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-BGgCBSx1.js"));
+			const { getHyperClawDir: getHyperClawDir$1 } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+			const path$3 = (await import("path")).default;
+			const targetDir = getHyperClawDir$1();
+			await initWorkspaceFiles({
+				agentName: "Hyper",
+				personality: "helpful and concise",
+				language: "English",
+				userName: "User",
+				rules: []
+			}, targetDir, selectedFiles);
+			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-OQbgmenS.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-Cqen1Mpt.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--wG9JdFW.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-C4esBfbX.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-BbLQTzZk.js"));
+				const { writeOAuthToken } = await Promise.resolve().then(() => require("./oauth-provider-UZyG84s7.js"));
+				const tokens = await runOAuthFlow(provider, {});
+				const now = Math.floor(Date.now() / 1e3);
+				const TOKEN_URLS = {
+					"google-calendar": "https://oauth2.googleapis.com/token",
+					"google-drive": "https://oauth2.googleapis.com/token",
+					"github": "https://github.com/login/oauth/access_token",
+					"notion": "https://api.notion.com/v1/oauth/token",
+					"linear": "https://api.linear.app/oauth/token"
+				};
+				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: TOKEN_URLS[provider] ?? "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-ChorJKFL.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 cfg = await this.config.load();
+				const bindings = Array.isArray(cfg?.bindings) ? [...cfg.bindings] : [];
+				bindings.push({
+					match: { channel: r.channel.trim() },
+					agentId: r.agentName.trim()
+				});
+				await this.config.patch({ bindings });
+				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: [] };
+		const pkgVersion = await fs_extra.default.readJson(path.default.join(__dirname, "../package.json")).then((p) => p.version).catch(() => "5.2.0");
+		const channelIds = Object.keys(data.channelConfigs || {});
+		let gatewayToSave = data.gatewayConfig ? {
+			...data.gatewayConfig,
+			enabledChannels: channelIds
+		} : current?.gateway ? { ...current.gateway } : void 0;
+		if (gatewayToSave && channelIds.length > 0) gatewayToSave.enabledChannels = channelIds;
+		await this.config.save({
+			...current,
+			version: pkgVersion,
+			workspaceName: data.workspaceName,
+			provider: data.providerConfig,
+			providers: data.providers || (data.providerConfig ? [data.providerConfig] : []),
+			gateway: gatewayToSave,
+			channels: channelIds,
+			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-Dq_cDlOW.js"));
+			const loader = new HookLoader();
+			loader.enable("morning-briefing");
+			console.log(chalk.default.gray("  ✔  Morning Briefing hook enabled"));
+		} catch {}
+		await this.testConnections(data.channelConfigs || {});
+		await this.setupIntegrations();
+		const isRemoteMode = data.gatewayConfig?.mode === "remote";
+		if (!isRemoteMode && (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 (!isRemoteMode && data.gatewayConfig?.tailscaleExposure && data.gatewayConfig.tailscaleExposure !== "off") await this.gateway.applyTailscaleExposure(data.gatewayConfig.tailscaleExposure, data.gatewayConfig.port);
+		if (data.gatewayConfig && !isRemoteMode && (options.startNow || data.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}`);
+		} else if (isRemoteMode) {
+			const remoteUrl = data.gatewayConfig?.remote?.url;
+			console.log(chalk.default.green(`  Remote mode: connect to ${remoteUrl || "(configured URL)"}\n`));
+		}
+		console.log(chalk.default.gray("\n  Running health check...\n"));
+		const healthResults = {};
+		try {
+			const { runDoctor } = await Promise.resolve().then(() => require("./doctor-mgWumA25.js"));
+			await runDoctor(true);
+			healthResults.doctor = "ok";
+		} catch {
+			healthResults.doctor = "failed";
+		}
+		if (data.gatewayConfig) try {
+			const { resolveGatewayUrl } = await Promise.resolve().then(() => require("./health-C8n9RH5O.js"));
+			const { gatewayUrl } = resolveGatewayUrl({ gateway: data.gatewayConfig });
+			const reachable = await new Promise((resolve) => {
+				const u = new URL(gatewayUrl);
+				const mod = u.protocol === "https:" ? require("https") : require("http");
+				const req = mod.get(`${gatewayUrl}/api/status`, () => resolve(true));
+				req.on("error", () => resolve(false));
+				req.setTimeout(5e3, () => {
+					req.destroy();
+					resolve(false);
+				});
+			});
+			healthResults.gateway = reachable ? "reachable" : "unreachable";
+			if (reachable) console.log(chalk.default.green(`  Gateway reachable at ${gatewayUrl}`));
+			else console.log(chalk.default.yellow(`  Gateway not reachable at ${gatewayUrl}`));
+		} catch {
+			healthResults.gateway = "error";
+		}
+		if (options.jsonOutput) {
+			const result = {
+				ok: true,
+				version: pkgVersion,
+				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, healthResults.gateway === "reachable");
+		const hatchMode = data.hatchMode || "tui";
+		if (hatchMode === "tui") {
+			const agentName = data.identity?.agentName || "HyperClaw";
+			const userName = data.identity?.userName || require("os").userInfo().username;
+			const now = /* @__PURE__ */ new Date();
+			const dayName = now.toLocaleDateString("en-US", { weekday: "long" });
+			const dateStr = now.toLocaleDateString("en-US", {
+				month: "long",
+				day: "numeric",
+				year: "numeric"
+			});
+			console.log(chalk.default.bold.cyan("\n  🌅 Wake up, my friend!\n"));
+			console.log(chalk.default.gray(`  ${dayName}, ${dateStr}`));
+			console.log(chalk.default.gray(`  I am ${agentName}. Hello, ${userName}.`));
+			console.log(chalk.default.gray("  Fresh out of the box — who are you, and who am I? What should we call each other?"));
+			console.log(chalk.default.gray("  (Refine in chat.)\n"));
+			console.log(chalk.default.gray("  Starting chat...\n"));
+			const { runChat } = await Promise.resolve().then(() => require("./chat-D-i8bqTf.js"));
+			await runChat({});
+		} else if (hatchMode === "web" && data.gatewayConfig && !data.gatewayConfig.remote) {
+			const port = data.gatewayConfig.port ?? 18789;
+			const url = `http://localhost:${port}`;
+			const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+			const { execFile } = await import("child_process");
+			const { promisify } = await import("util");
+			try {
+				await promisify(execFile)(openCmd, [url], { timeout: 3e3 });
+				console.log(chalk.default.green(`\n  Opened ${url} in your browser.\n`));
+			} catch {
+				console.log(chalk.default.gray(`\n  Open in browser: ${url}\n`));
+			}
+		} else if (hatchMode === "skip") console.log(chalk.default.gray("\n  Run hyperclaw chat or open the Web UI when ready.\n"));
+	}
+	async setupIntegrations() {
+		console.log();
+		const { configure } = await inquirer.default.prompt([{
+			type: "confirm",
+			name: "configure",
+			message: chalk.default.cyan("Configure integrations now?") + chalk.default.gray(" (Spotify, Home Assistant, GitHub, Trello, etc.)"),
+			default: false
+		}]);
+		if (!configure) {
+			console.log(chalk.default.gray("  Skipped — configure later by telling the agent or running: hyperclaw config set-key KEY value\n"));
+			return;
+		}
+		const INTEGRATIONS = [
+			{
+				name: "Spotify",
+				value: "spotify",
+				instructions: [
+					"1. Go to → https://developer.spotify.com/dashboard",
+					"2. Log in and click \"Create App\"",
+					"3. Fill in name/description, set Redirect URI to http://localhost:8888/callback",
+					"4. Click \"Settings\" → copy your Client ID and Client Secret",
+					"5. To get a Refresh Token, run this after saving Client ID/Secret:",
+					"   npx spotify-token  (or use the Spotify OAuth Playground)"
+				],
+				keys: [
+					{
+						env: "SPOTIFY_CLIENT_ID",
+						label: "Client ID"
+					},
+					{
+						env: "SPOTIFY_CLIENT_SECRET",
+						label: "Client Secret",
+						secret: true
+					},
+					{
+						env: "SPOTIFY_REFRESH_TOKEN",
+						label: "Refresh Token",
+						secret: true
+					}
+				]
+			},
+			{
+				name: "Home Assistant",
+				value: "ha",
+				instructions: [
+					"1. Open Home Assistant in your browser",
+					"2. Go to → Profile (bottom left) → Long-lived access tokens",
+					"3. Click \"Create Token\", give it a name (e.g. HyperClaw)",
+					"4. Copy the token immediately — it won't be shown again",
+					"5. Your URL is usually http://homeassistant.local:8123 or your local IP"
+				],
+				keys: [{
+					env: "HA_URL",
+					label: "URL (e.g. http://homeassistant.local:8123)"
+				}, {
+					env: "HA_TOKEN",
+					label: "Long-lived Access Token",
+					secret: true
+				}]
+			},
+			{
+				name: "GitHub",
+				value: "github",
+				instructions: [
+					"1. Go to → https://github.com/settings/tokens",
+					"2. Click \"Generate new token (classic)\"",
+					"3. Give it a name (e.g. HyperClaw)",
+					"4. Select scopes: repo, read:user, read:org (or as needed)",
+					"5. Click \"Generate token\" and copy it — shown only once"
+				],
+				keys: [{
+					env: "GITHUB_TOKEN",
+					label: "Personal Access Token",
+					secret: true
+				}]
+			},
+			{
+				name: "Trello",
+				value: "trello",
+				instructions: [
+					"1. Go to → https://trello.com/app-key",
+					"2. Copy your API Key from the top of the page",
+					"3. On the same page, click \"Token\" link to generate a Token",
+					"4. Authorize the app and copy the token"
+				],
+				keys: [{
+					env: "TRELLO_API_KEY",
+					label: "API Key"
+				}, {
+					env: "TRELLO_TOKEN",
+					label: "Token",
+					secret: true
+				}]
+			},
+			{
+				name: "Obsidian",
+				value: "obsidian",
+				instructions: [
+					"1. Open Obsidian → Settings → Community Plugins",
+					"2. Search for \"Local REST API\" and install it",
+					"3. Enable the plugin and go to its settings",
+					"4. Copy the API Key shown in the plugin settings",
+					"5. The default port is 27123 (leave blank to use default)"
+				],
+				keys: [{
+					env: "OBSIDIAN_API_KEY",
+					label: "Local REST API Key",
+					secret: true
+				}, {
+					env: "OBSIDIAN_PORT",
+					label: "Port (press Enter for default 27123)"
+				}]
+			},
+			{
+				name: "Philips Hue",
+				value: "hue",
+				instructions: [
+					"1. Find your Hue Bridge IP: open the Hue app → Settings → My Hue System → Bridge",
+					"   OR check your router's device list for \"Philips-hue\"",
+					"2. Go to → http://<BRIDGE_IP>/debug/clip.html",
+					"3. In the URL field type: /api",
+					"   Body: {\"devicetype\":\"hyperclaw#mydevice\"}",
+					"4. Press the physical button on the bridge, then click POST",
+					"5. Copy the \"username\" value from the response — that's your HUE_USERNAME"
+				],
+				keys: [{
+					env: "HUE_BRIDGE_IP",
+					label: "Bridge IP (e.g. 192.168.1.100)"
+				}, {
+					env: "HUE_USERNAME",
+					label: "Username (from bridge pairing)"
+				}]
+			},
+			{
+				name: "8Sleep",
+				value: "eightsleep",
+				instructions: [
+					"1. Use your Eight Sleep account email and password",
+					"2. These are the same credentials you use in the Eight Sleep app",
+					"   Note: 8Sleep has rate limits — don't query too frequently"
+				],
+				keys: [{
+					env: "EIGHTSLEEP_EMAIL",
+					label: "Email"
+				}, {
+					env: "EIGHTSLEEP_PASSWORD",
+					label: "Password",
+					secret: true
+				}]
+			},
+			{
+				name: "Sonos",
+				value: "sonos",
+				instructions: [
+					"1. Find your Sonos speaker's local IP address",
+					"2. Open the Sonos app → System → (your room) → About My System",
+					"   OR check your router's device list for your Sonos device",
+					"3. The IP looks like: 192.168.1.x"
+				],
+				keys: [{
+					env: "SONOS_IP",
+					label: "Speaker IP (e.g. 192.168.1.50)"
+				}]
+			},
+			{
+				name: "Giphy / GIF search",
+				value: "giphy",
+				instructions: [
+					"Option A — Giphy:",
+					"1. Go to → https://developers.giphy.com",
+					"2. Log in or sign up → Dashboard → Create an App → API",
+					"3. Copy your API Key",
+					"",
+					"Option B — Tenor (Google):",
+					"1. Go to → https://console.cloud.google.com",
+					"2. Enable the \"Tenor API\" → Create credentials → API Key",
+					"   (You can leave one blank and only fill the other)"
+				],
+				keys: [{
+					env: "GIPHY_API_KEY",
+					label: "Giphy API Key (leave blank to skip)"
+				}, {
+					env: "TENOR_API_KEY",
+					label: "Tenor API Key (leave blank to skip)"
+				}]
+			},
+			{
+				name: "1Password",
+				value: "1password",
+				instructions: [
+					"1. Install the 1Password CLI: https://developer.1password.com/docs/cli/get-started/",
+					"2. Go to → https://my.1password.com → Integrations → Service Accounts",
+					"3. Create a new Service Account, give it read access to the vaults you need",
+					"4. Copy the Service Account Token — shown only once",
+					"5. Verify the CLI works: op account list"
+				],
+				keys: [{
+					env: "OP_SERVICE_ACCOUNT_TOKEN",
+					label: "Service Account Token",
+					secret: true
+				}]
+			},
+			{
+				name: "Image Generation (DALL-E / Stability AI)",
+				value: "image_gen",
+				instructions: [
+					"Option A — OpenAI DALL-E 3 (recommended):",
+					"1. Go to → https://platform.openai.com/api-keys",
+					"2. Click \"Create new secret key\", give it a name",
+					"3. Copy the key — shown only once (starts with sk-...)",
+					"   Note: DALL-E 3 requires a paid OpenAI plan",
+					"",
+					"Option B — Stability AI (Stable Diffusion):",
+					"1. Go to → https://platform.stability.ai/account/keys",
+					"2. Create an account and click \"Create API Key\"",
+					"3. Copy the key",
+					"   (You can set both — the agent will prefer DALL-E if both are present)"
+				],
+				keys: [{
+					env: "OPENAI_API_KEY",
+					label: "OpenAI API Key (for DALL-E 3, leave blank to skip)",
+					secret: true
+				}, {
+					env: "STABILITY_API_KEY",
+					label: "Stability AI Key (for Stable Diffusion, leave blank to skip)",
+					secret: true
+				}]
+			},
+			{
+				name: "Gmail",
+				value: "gmail",
+				instructions: [
+					"1. Go to → https://console.cloud.google.com",
+					"2. Create a project (or select an existing one)",
+					"3. Enable APIs: \"Gmail API\" and \"Cloud Pub/Sub API\"",
+					"4. Go to → APIs & Services → Credentials → Create OAuth 2.0 Client ID",
+					"   Application type: Desktop App",
+					"5. Download the JSON credentials file",
+					"6. Set GOOGLE_CREDENTIALS_PATH to the path of that file",
+					"7. For Pub/Sub (push notifications), create a topic and subscription:",
+					"   gcloud pubsub topics create hyperclaw-gmail",
+					"   gcloud pubsub subscriptions create hyperclaw-sub --topic=hyperclaw-gmail",
+					"   Then set GMAIL_PUBSUB_TOPIC to projects/<project-id>/topics/hyperclaw-gmail"
+				],
+				keys: [{
+					env: "GOOGLE_CREDENTIALS_PATH",
+					label: "Path to credentials JSON file (e.g. ~/Downloads/credentials.json)"
+				}, {
+					env: "GMAIL_PUBSUB_TOPIC",
+					label: "Pub/Sub topic (leave blank to skip push notifications)"
+				}]
+			}
+		];
+		console.log(chalk.default.gray("\n  Free / built-in (no key needed):"));
+		console.log(chalk.default.gray("  • Weather (Open-Meteo)  • Music search (iTunes)  • Canvas  • Browser"));
+		console.log(chalk.default.gray("  • Apple Notes / Reminders / Things 3 / Bear (macOS)  • iMessage (macOS)\n"));
+		const { chosen } = await inquirer.default.prompt([{
+			type: "checkbox",
+			name: "chosen",
+			message: "Select integrations to configure (need API keys):",
+			choices: [...INTEGRATIONS.map((i) => ({
+				name: i.name,
+				value: i.value
+			}))],
+			pageSize: 14
+		}]);
+		if (chosen.length === 0) {
+			console.log(chalk.default.gray("  No integrations selected. You can add them later with: hyperclaw config set-key KEY value\n"));
+			return;
+		}
+		const { getEnvFilePath } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+		const envPath = getEnvFilePath();
+		const envLines = [];
+		try {
+			const existing = await fs_extra.default.readFile(envPath, "utf8").catch(() => "");
+			envLines.push(...existing.split("\n").filter((l) => l.trim()));
+		} catch {}
+		for (const id of chosen) {
+			const integration = INTEGRATIONS.find((i) => i.value === id);
+			console.log("\n" + chalk.default.bold.cyan(`  ── ${integration.name} ──`));
+			if (integration.instructions.length > 0) {
+				console.log(chalk.default.gray("\n  How to get your credentials:\n"));
+				for (const line of integration.instructions) if (line === "") console.log();
+				else if (/^\d+\./.test(line.trim())) console.log(chalk.default.white(`  ${line}`));
+				else console.log(chalk.default.gray(`  ${line}`));
+				console.log();
+				const { ready } = await inquirer.default.prompt([{
+					type: "confirm",
+					name: "ready",
+					message: `  Ready to enter your ${integration.name} credentials?`,
+					default: true
+				}]);
+				if (!ready) {
+					console.log(chalk.default.gray(`  Skipped — add later: hyperclaw config set-key KEY value\n`));
+					continue;
+				}
+			}
+			for (const key of integration.keys) {
+				const { val } = await inquirer.default.prompt([{
+					type: key.secret ? "password" : "input",
+					name: "val",
+					message: `  ${key.label}:`,
+					mask: key.secret ? "*" : void 0
+				}]);
+				if (val && val.trim()) {
+					const line = `${key.env}=${val.trim()}`;
+					const idx = envLines.findIndex((l) => l.startsWith(`${key.env}=`));
+					if (idx >= 0) envLines[idx] = line;
+					else envLines.push(line);
+					console.log(chalk.default.green(`  ✔  ${key.env} saved`));
+				} else console.log(chalk.default.gray(`  –  ${key.env} skipped`));
+			}
+		}
+		await fs_extra.default.ensureDir(path.default.dirname(envPath));
+		await fs_extra.default.writeFile(envPath, envLines.filter(Boolean).join("\n") + "\n", "utf8");
+		console.log(chalk.default.green(`\n  ✔  Integration keys saved to ~/.hyperclaw/.env`));
+		console.log(chalk.default.gray("  To add more later: hyperclaw config set-key KEY value\n"));
+	}
+	async testConnections(configs) {
+		for (const [channelId, cfg] of Object.entries(configs)) {
+			const ch = CHANNELS.find((c) => c.id === channelId);
+			if (!ch) continue;
+			const skipIds = [
+				"whatsapp-baileys",
+				"voice-call",
+				"web",
+				"imessage-native",
+				"irc",
+				"signal",
+				"tlon"
+			];
+			if (skipIds.includes(channelId)) {
+				console.log(chalk.default.gray(`  ${ch.emoji} ${ch.name} — skipped (requires runtime setup)`));
+				continue;
+			}
+			if (!cfg?.token) {
+				console.log(chalk.default.gray(`  ${ch.emoji} ${ch.name} — skipped (no token)`));
+				continue;
+			}
+			const s = (0, ora.default)(`  Testing ${ch.emoji} ${ch.name}...`).start();
+			try {
+				const ok = await this.validateChannelToken(channelId, cfg);
+				if (ok) s.succeed(chalk.default.green(`${ch.emoji} ${ch.name} — token valid`));
+				else {
+					s.fail(chalk.default.red(`${ch.emoji} ${ch.name} — invalid token or wrong credentials`));
+					const { getConfigPath } = await Promise.resolve().then(() => require("./paths-D-QecARF.js"));
+					console.log(chalk.default.gray(`    Fix: hyperclaw channels add ${channelId}`));
+					console.log(chalk.default.gray(`    Or edit: ${getConfigPath()} (channelConfigs.${channelId})`));
+				}
+			} catch (e) {
+				s.warn(chalk.default.yellow(`${ch.emoji} ${ch.name} — could not verify (${e.message?.slice(0, 60) ?? "timeout"})`));
+			}
+		}
+	}
+	async validateChannelToken(channelId, cfg) {
+		const token = cfg.token ?? "";
+		const timeout = 8e3;
+		const fetchWithTimeout = async (url, init) => {
+			const ctrl = new AbortController();
+			const t = setTimeout(() => ctrl.abort(), timeout);
+			try {
+				return await fetch(url, {
+					...init,
+					signal: ctrl.signal
+				});
+			} finally {
+				clearTimeout(t);
+			}
+		};
+		switch (channelId) {
+			case "telegram": {
+				const r = await fetchWithTimeout(`https://api.telegram.org/bot${token}/getMe`);
+				const j = await r.json();
+				return j?.ok === true;
+			}
+			case "discord": {
+				const r = await fetchWithTimeout("https://discord.com/api/v10/users/@me", { headers: { Authorization: `Bot ${token}` } });
+				const j = await r.json();
+				return !!j?.id;
+			}
+			case "slack": {
+				const r = await fetchWithTimeout("https://slack.com/api/auth.test", {
+					method: "POST",
+					headers: {
+						Authorization: `Bearer ${token}`,
+						"Content-Type": "application/json"
+					}
+				});
+				const j = await r.json();
+				return j?.ok === true;
+			}
+			case "matrix": {
+				const homeserver = (cfg.homeserver ?? "").replace(/\/$/, "");
+				if (!homeserver) return false;
+				const r = await fetchWithTimeout(`${homeserver}/_matrix/client/v3/account/whoami`, { headers: { Authorization: `Bearer ${token}` } });
+				const j = await r.json();
+				return !!j?.user_id;
+			}
+			case "line": {
+				const r = await fetchWithTimeout("https://api.line.me/v2/bot/info", { headers: { Authorization: `Bearer ${token}` } });
+				const j = await r.json();
+				return !!j?.userId;
+			}
+			case "viber": {
+				const r = await fetchWithTimeout("https://chatapi.viber.com/pa/get_account_info", {
+					method: "POST",
+					headers: {
+						"X-Viber-Auth-Token": token,
+						"Content-Type": "application/json"
+					},
+					body: JSON.stringify({})
+				});
+				const j = await r.json();
+				return j?.status === 0;
+			}
+			case "mattermost": {
+				const serverUrl = (cfg.serverUrl ?? "").replace(/\/$/, "");
+				if (!serverUrl) return false;
+				const r = await fetchWithTimeout(`${serverUrl}/api/v4/users/me`, { headers: { Authorization: `Bearer ${token}` } });
+				const j = await r.json();
+				return !!j?.id;
+			}
+			case "messenger":
+			case "instagram":
+			case "whatsapp": {
+				const r = await fetchWithTimeout(`https://graph.facebook.com/me?access_token=${token}`);
+				const j = await r.json();
+				return !!j?.id;
+			}
+			case "feishu": {
+				const appSecret = cfg.appSecret ?? "";
+				const r = await fetchWithTimeout("https://open.feishu.cn/open-apis/auth/v3/app_access_token/internal", {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({
+						app_id: token,
+						app_secret: appSecret
+					})
+				});
+				const j = await r.json();
+				return j?.code === 0;
+			}
+			case "googlechat": return /^https:\/\/chat\.googleapis\.com\/v1\/spaces\/.+\/messages/.test(token);
+			case "nostr": return /^[0-9a-f]{64}$/.test(token) || token.startsWith("nsec");
+			case "email": {
+				const user = cfg.user ?? "";
+				const imapHost = cfg.imapHost ?? "";
+				const smtpHost = cfg.smtpHost ?? "";
+				return /^[^@]+@[^@]+\.[^@]+$/.test(user) && imapHost.length > 3 && smtpHost.length > 3 && token.length > 3;
+			}
+			case "nextcloud": {
+				const serverUrl = (cfg.serverUrl ?? "").replace(/\/$/, "");
+				const username = cfg.username ?? "";
+				if (!serverUrl || !username) return false;
+				const creds = Buffer.from(`${username}:${token}`).toString("base64");
+				const r = await fetchWithTimeout(`${serverUrl}/ocs/v1.php/cloud/user?format=json`, { headers: {
+					Authorization: `Basic ${creds}`,
+					"OCS-APIREQUEST": "true"
+				} });
+				const j = await r.json();
+				return j?.ocs?.meta?.status === "ok";
+			}
+			case "twitter": return token.length > 0 && (cfg.apiKeySecret ?? "").length > 0 && (cfg.accessToken ?? "").length > 0 && (cfg.accessTokenSecret ?? "").length > 0;
+			case "msteams": return token.length > 8 && (cfg.appPassword ?? "").length > 3;
+			case "zalo": return token.length > 0 && (cfg.secretKey ?? "").length > 0;
+			case "imessage": return token.length > 3;
+			default: return token.length > 0;
+		}
+	}
+	showSuccessScreen(data, gatewayReachable = false) {
+		const channels = Object.keys(data.channelConfigs || {});
+		const gwUrl = `ws://localhost:${data.gatewayConfig?.port ?? 18789}`;
+		const hasEmail = channels.includes("email");
+		const hasHyperClawBot = !!data.hyperclawbotConfig?.token;
+		const isRemoteMode = data.gatewayConfig?.mode === "remote";
+		const needsStart = data.gatewayConfig && !isRemoteMode && !gatewayReachable && channels.length > 0;
+		const cmdLines = [
+			chalk.default.gray("  📊 hyperclaw dashboard         Dashboard (terminal)"),
+			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 (needsStart) cmdLines.unshift(chalk.default.yellow("  🚀 hyperclaw daemon start       ") + chalk.default.bold("Start your bot (Telegram/Discord need this!)"));
+		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.3.45 ready!\n\n") + lines, {
+			padding: 1,
+			borderStyle: "round",
+			borderColor: "cyan",
+			margin: 1,
+			backgroundColor: "#0a0a0a"
+		}));
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'HyperClawWizard', {
+  enumerable: true,
+  get: function () {
+    return HyperClawWizard;
+  }
+});