pawmode 1.0.0

package/dist/index.js

@@ -0,0 +1,2925 @@
+#!/usr/bin/env node
+import { getDefaultSkillsDir, installSkill, isSkillInstalled, listInstalledSkills, removeSkill } from "./skills-CJ_pyPlv.js";
+import { addPermissions, readSettings, removePermissions, writeSettings } from "./permissions-BHOAvP8i.js";
+import { Command } from "commander";
+import * as p$11 from "@clack/prompts";
+import * as p$10 from "@clack/prompts";
+import * as p$9 from "@clack/prompts";
+import * as p$8 from "@clack/prompts";
+import * as p$7 from "@clack/prompts";
+import * as p$6 from "@clack/prompts";
+import * as p$5 from "@clack/prompts";
+import * as p$4 from "@clack/prompts";
+import * as p$3 from "@clack/prompts";
+import * as p$2 from "@clack/prompts";
+import * as p$1 from "@clack/prompts";
+import * as p from "@clack/prompts";
+import * as os$6 from "node:os";
+import * as os$5 from "node:os";
+import * as os$4 from "node:os";
+import * as os$3 from "node:os";
+import * as os$2 from "node:os";
+import * as os$1 from "node:os";
+import os from "node:os";
+import chalk from "chalk";
+import { execSync, spawn } from "node:child_process";
+import * as fs$4 from "node:fs";
+import * as fs$3 from "node:fs";
+import * as fs$2 from "node:fs";
+import * as fs$1 from "node:fs";
+import fs from "node:fs";
+import * as path$4 from "node:path";
+import * as path$3 from "node:path";
+import * as path$2 from "node:path";
+import * as path$1 from "node:path";
+import path from "node:path";
+import { Bot } from "grammy";
+import { hydrate } from "@grammyjs/hydrate";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+//#region src/catalog/index.ts
+const memo = {
+	name: "memo",
+	command: "memo",
+	installCmd: "brew install steipete/tap/memo",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: ["darwin"]
+};
+const remindctl = {
+	name: "remindctl",
+	command: "remindctl",
+	installCmd: "brew install steipete/tap/remindctl",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: ["darwin"]
+};
+const obsidianCli = {
+	name: "obsidian-cli",
+	command: "obsidian-cli",
+	installCmd: "brew install yakitrak/yakitrak/obsidian-cli",
+	installMethod: "brew-tap",
+	tap: "yakitrak/yakitrak",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const notionCli = {
+	name: "notion-cli",
+	command: "notion-cli",
+	installCmd: "npm install -g notion-cli-tool",
+	installMethod: "npm",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const todoistCli = {
+	name: "todoist-cli",
+	command: "todoist",
+	installCmd: "brew install todoist-cli",
+	installMethod: "brew",
+	platforms: ["darwin", "linux"]
+};
+const thingsCli = {
+	name: "things-cli",
+	command: "things-cli",
+	installCmd: "pip3 install things-cli",
+	installMethod: "pip",
+	platforms: ["darwin"]
+};
+const taskwarrior = {
+	name: "taskwarrior",
+	command: "task",
+	installCmd: "brew install task",
+	installMethod: "brew",
+	platforms: ["darwin", "linux"]
+};
+const gogcli = {
+	name: "gogcli",
+	command: "gog",
+	installCmd: "brew install steipete/tap/gogcli",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const himalaya = {
+	name: "himalaya",
+	command: "himalaya",
+	installCmd: "brew install himalaya",
+	installMethod: "brew",
+	platforms: ["darwin", "linux"]
+};
+const icalpal = {
+	name: "icalpal",
+	command: "icalpal",
+	installCmd: "brew install icalpal",
+	installMethod: "brew",
+	platforms: ["darwin"]
+};
+const imsg = {
+	name: "imsg",
+	command: "imsg",
+	installCmd: "brew install steipete/tap/imsg",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: ["darwin"]
+};
+const wacli = {
+	name: "wacli",
+	command: "wacli",
+	installCmd: "brew install steipete/tap/wacli",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: ["darwin"]
+};
+const slackCli = {
+	name: "slack-cli",
+	command: "slack",
+	installCmd: "brew tap rockymadden/rockymadden && brew install rockymadden/rockymadden/slack-cli",
+	installMethod: "brew-tap",
+	tap: "rockymadden/rockymadden",
+	platforms: ["darwin", "linux"]
+};
+const bird = {
+	name: "bird",
+	command: "bird",
+	installCmd: "brew install steipete/tap/bird",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const spogo = {
+	name: "spogo",
+	command: "spogo",
+	installCmd: "brew install steipete/tap/spogo",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const ytdlp = {
+	name: "yt-dlp",
+	command: "yt-dlp",
+	installCmd: "brew install yt-dlp",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const ffmpeg = {
+	name: "ffmpeg",
+	command: "ffmpeg",
+	installCmd: "brew install ffmpeg",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const peekaboo = {
+	name: "peekaboo",
+	command: "peekaboo",
+	installCmd: "brew install steipete/tap/peekaboo",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: ["darwin"]
+};
+const camsnap = {
+	name: "camsnap",
+	command: "camsnap",
+	installCmd: "brew install steipete/tap/camsnap",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: ["darwin"]
+};
+const sag = {
+	name: "sag",
+	command: "sag",
+	installCmd: "brew install steipete/tap/sag",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: ["darwin"]
+};
+const openhue = {
+	name: "openhue",
+	command: "openhue",
+	installCmd: "brew install openhue-cli",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const sonoscli = {
+	name: "sonoscli",
+	command: "sonos",
+	installCmd: "brew install steipete/tap/sonoscli",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const blucli = {
+	name: "blucli",
+	command: "blu",
+	installCmd: "brew install steipete/tap/blucli",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: ["darwin"]
+};
+const summarize = {
+	name: "summarize",
+	command: "summarize",
+	installCmd: "brew install steipete/tap/summarize",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const goplaces = {
+	name: "goplaces",
+	command: "goplaces",
+	installCmd: "brew install steipete/tap/goplaces",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: ["darwin"]
+};
+const ordercli = {
+	name: "ordercli",
+	command: "ordercli",
+	installCmd: "brew install steipete/tap/ordercli",
+	installMethod: "brew-tap",
+	tap: "steipete/tap",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const onepassCli = {
+	name: "1password-cli",
+	command: "op",
+	installCmd: "brew install --cask 1password-cli",
+	installMethod: "brew-cask",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const bitwardenCli = {
+	name: "bitwarden-cli",
+	command: "bw",
+	installCmd: "npm install -g @bitwarden/cli",
+	installMethod: "npm",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const gh = {
+	name: "gh",
+	command: "gh",
+	installCmd: "brew install gh",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const jq = {
+	name: "jq",
+	command: "jq",
+	installCmd: "brew install jq",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const linearCli = {
+	name: "linear-cli",
+	command: "linear",
+	installCmd: "npm install -g @linear/cli",
+	installMethod: "npm",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const jiraCli = {
+	name: "jira-cli",
+	command: "jira",
+	installCmd: "brew install jira-cli",
+	installMethod: "brew",
+	platforms: ["darwin", "linux"]
+};
+const agentBrowser = {
+	name: "agent-browser",
+	command: "agent-browser",
+	installCmd: "npm install -g agent-browser",
+	installMethod: "npm",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const playwrightCli = {
+	name: "playwright-cli",
+	command: "playwright-cli",
+	installCmd: "npm install -g @playwright/cli@latest",
+	installMethod: "npm",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const mcli = {
+	name: "m-cli",
+	command: "m",
+	installCmd: "brew install m-cli",
+	installMethod: "brew",
+	platforms: ["darwin"]
+};
+const mas = {
+	name: "mas",
+	command: "mas",
+	installCmd: "brew install mas",
+	installMethod: "brew",
+	platforms: ["darwin"]
+};
+const macosTrash = {
+	name: "macos-trash",
+	command: "trash",
+	installCmd: "brew install macos-trash",
+	installMethod: "brew",
+	platforms: ["darwin"]
+};
+const brightness = {
+	name: "brightness",
+	command: "brightness",
+	installCmd: "brew install brightness",
+	installMethod: "brew",
+	platforms: ["darwin"]
+};
+const lunchyGo = {
+	name: "lunchy-go",
+	command: "lunchy-go",
+	installCmd: "brew install lunchy-go",
+	installMethod: "brew",
+	platforms: ["darwin"]
+};
+const rclone = {
+	name: "rclone",
+	command: "rclone",
+	installCmd: "brew install rclone",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const terminalNotifier = {
+	name: "terminal-notifier",
+	command: "terminal-notifier",
+	installCmd: "brew install terminal-notifier",
+	installMethod: "brew",
+	platforms: ["darwin"]
+};
+const doggo = {
+	name: "doggo",
+	command: "doggo",
+	installCmd: "brew install doggo",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const httpie = {
+	name: "httpie",
+	command: "http",
+	installCmd: "brew install httpie",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const llmCli = {
+	name: "llm",
+	command: "llm",
+	installCmd: "brew install llm",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const aichat = {
+	name: "aichat",
+	command: "aichat",
+	installCmd: "brew install aichat",
+	installMethod: "brew",
+	platforms: [
+		"darwin",
+		"linux",
+		"win32"
+	]
+};
+const skills = [
+	{
+		id: "notes",
+		name: "Notes & Reminders",
+		description: "Read/write Apple Notes, manage Apple Reminders",
+		category: "productivity",
+		tools: [memo, remindctl],
+		platforms: ["darwin"]
+	},
+	{
+		id: "obsidian",
+		name: "Obsidian",
+		description: "Manage Obsidian vaults — open, search, navigate notes",
+		category: "productivity",
+		tools: [obsidianCli],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		]
+	},
+	{
+		id: "notion",
+		name: "Notion",
+		description: "Manage Notion pages and databases from the CLI",
+		category: "productivity",
+		tools: [notionCli],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		]
+	},
+	{
+		id: "tasks",
+		name: "Tasks",
+		description: "Task management — Todoist, Things 3, or Taskwarrior",
+		category: "productivity",
+		tools: [],
+		platforms: ["darwin", "linux"],
+		subChoices: {
+			question: "Which task manager?",
+			options: [
+				{
+					label: "Todoist",
+					value: "todoist",
+					tools: [todoistCli]
+				},
+				{
+					label: "Things 3 (macOS)",
+					value: "things",
+					tools: [thingsCli]
+				},
+				{
+					label: "Taskwarrior (local)",
+					value: "taskwarrior",
+					tools: [taskwarrior]
+				}
+			]
+		}
+	},
+	{
+		id: "email",
+		name: "Email",
+		description: "Read, send, and search email — Gmail or IMAP",
+		category: "communication",
+		tools: [],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		subChoices: {
+			question: "Which email provider?",
+			options: [
+				{
+					label: "Gmail (Google)",
+					value: "gmail",
+					tools: [gogcli]
+				},
+				{
+					label: "IMAP (any provider)",
+					value: "imap",
+					tools: [himalaya]
+				},
+				{
+					label: "Both",
+					value: "both",
+					tools: [gogcli, himalaya]
+				}
+			]
+		},
+		authSteps: [{
+			tool: "gogcli",
+			command: "gog auth",
+			description: "Sign into Google"
+		}, {
+			tool: "himalaya",
+			command: "himalaya account configure",
+			description: "Configure IMAP account"
+		}]
+	},
+	{
+		id: "calendar",
+		name: "Calendar",
+		description: "View and manage calendar events",
+		category: "communication",
+		tools: [],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		subChoices: {
+			question: "Which calendar?",
+			options: [
+				{
+					label: "Google Calendar",
+					value: "google",
+					tools: [gogcli]
+				},
+				{
+					label: "Apple Calendar (macOS)",
+					value: "apple",
+					tools: [icalpal]
+				},
+				{
+					label: "Both",
+					value: "both",
+					tools: [gogcli, icalpal]
+				}
+			]
+		},
+		authSteps: [{
+			tool: "gogcli",
+			command: "gog auth",
+			description: "Sign into Google"
+		}]
+	},
+	{
+		id: "messaging",
+		name: "Messaging",
+		description: "Send/read iMessage and WhatsApp",
+		category: "communication",
+		tools: [imsg, wacli],
+		platforms: ["darwin"],
+		authSteps: [{
+			tool: "wacli",
+			command: "wacli auth",
+			description: "Scan QR code for WhatsApp"
+		}]
+	},
+	{
+		id: "slack",
+		name: "Slack",
+		description: "Send messages and files to Slack channels",
+		category: "communication",
+		tools: [slackCli],
+		platforms: ["darwin", "linux"],
+		authSteps: [{
+			tool: "slack-cli",
+			command: "slack init",
+			description: "Configure Slack token"
+		}]
+	},
+	{
+		id: "social",
+		name: "Social / Twitter",
+		description: "Post tweets, read timeline, search Twitter/X",
+		category: "communication",
+		tools: [bird],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		authSteps: [{
+			tool: "bird",
+			command: "bird auth",
+			description: "Connect Twitter/X"
+		}]
+	},
+	{
+		id: "telegram",
+		name: "Telegram Bridge",
+		description: "Talk to Claude from your phone — full bidirectional Telegram bridge",
+		category: "communication",
+		tools: [],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		]
+	},
+	{
+		id: "music",
+		name: "Music / Spotify",
+		description: "Play, pause, skip, search, queue on Spotify",
+		category: "media",
+		tools: [spogo],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		authSteps: [{
+			tool: "spogo",
+			command: "spogo auth",
+			description: "Connect Spotify"
+		}]
+	},
+	{
+		id: "video",
+		name: "Video / YouTube",
+		description: "Download videos, extract audio, convert formats",
+		category: "media",
+		tools: [ytdlp, ffmpeg],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		]
+	},
+	{
+		id: "screen",
+		name: "Screen & Vision",
+		description: "Screenshots, OCR, screen analysis, webcam capture",
+		category: "media",
+		tools: [peekaboo, camsnap],
+		platforms: ["darwin"]
+	},
+	{
+		id: "voice",
+		name: "Voice",
+		description: "Speech-to-text and text-to-speech",
+		category: "media",
+		tools: [sag],
+		platforms: ["darwin"]
+	},
+	{
+		id: "lights",
+		name: "Lights / Hue",
+		description: "Control Philips Hue lights — on/off, brightness, color",
+		category: "smart-home",
+		tools: [openhue],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		authSteps: [{
+			tool: "openhue",
+			command: "openhue setup",
+			description: "Press Hue Bridge button"
+		}]
+	},
+	{
+		id: "speakers",
+		name: "Speakers / Sonos",
+		description: "Control Sonos speakers — play, volume, grouping",
+		category: "smart-home",
+		tools: [sonoscli],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		]
+	},
+	{
+		id: "bluetooth",
+		name: "Bluetooth",
+		description: "List, connect, disconnect Bluetooth devices",
+		category: "smart-home",
+		tools: [blucli],
+		platforms: ["darwin"]
+	},
+	{
+		id: "research",
+		name: "Web Research",
+		description: "Summarize URLs, PDFs, YouTube videos",
+		category: "research",
+		tools: [summarize],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		]
+	},
+	{
+		id: "location",
+		name: "Location / Maps",
+		description: "Search Apple Maps, find nearby places",
+		category: "research",
+		tools: [goplaces],
+		platforms: ["darwin"]
+	},
+	{
+		id: "tracking",
+		name: "Package Tracking",
+		description: "Track packages across UPS, FedEx, USPS, DHL",
+		category: "research",
+		tools: [ordercli],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		]
+	},
+	{
+		id: "secrets",
+		name: "Passwords",
+		description: "Access password vault — 1Password or Bitwarden",
+		category: "research",
+		tools: [],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		subChoices: {
+			question: "Which password manager?",
+			options: [{
+				label: "1Password",
+				value: "1password",
+				tools: [onepassCli]
+			}, {
+				label: "Bitwarden",
+				value: "bitwarden",
+				tools: [bitwardenCli]
+			}]
+		},
+		authSteps: [{
+			tool: "1password-cli",
+			command: "op signin",
+			description: "Sign into 1Password"
+		}, {
+			tool: "bitwarden-cli",
+			command: "bw login",
+			description: "Sign into Bitwarden"
+		}]
+	},
+	{
+		id: "github",
+		name: "GitHub",
+		description: "PRs, issues, repos, actions — GitHub from the CLI",
+		category: "developer",
+		tools: [gh, jq],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		authSteps: [{
+			tool: "gh",
+			command: "gh auth login",
+			description: "Sign into GitHub"
+		}]
+	},
+	{
+		id: "linear",
+		name: "Linear",
+		description: "Manage Linear issues, projects, and cycles",
+		category: "developer",
+		tools: [linearCli],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		authSteps: [{
+			tool: "linear-cli",
+			command: "linear auth",
+			description: "Sign into Linear"
+		}]
+	},
+	{
+		id: "jira",
+		name: "Jira",
+		description: "Manage Jira issues, sprints, and boards",
+		category: "developer",
+		tools: [jiraCli],
+		platforms: ["darwin", "linux"],
+		authSteps: [{
+			tool: "jira-cli",
+			command: "jira init",
+			description: "Configure Jira instance"
+		}]
+	},
+	{
+		id: "briefing",
+		name: "Daily Briefing",
+		description: "Morning summary of email, calendar, tasks, and more",
+		category: "automation",
+		tools: [],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		depends: ["email", "calendar"]
+	},
+	{
+		id: "browser",
+		name: "Browser",
+		description: "Headless browser automation — navigate, click, fill forms, scrape",
+		category: "automation",
+		tools: [],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		subChoices: {
+			question: "Which browser engine?",
+			options: [
+				{
+					label: "Agent Browser (Vercel — built for AI)",
+					value: "agent-browser",
+					tools: [agentBrowser]
+				},
+				{
+					label: "Playwright CLI (Microsoft)",
+					value: "playwright",
+					tools: [playwrightCli]
+				},
+				{
+					label: "Both",
+					value: "both",
+					tools: [agentBrowser, playwrightCli]
+				}
+			]
+		}
+	},
+	{
+		id: "cron",
+		name: "Scheduling / Cron",
+		description: "Manage cron jobs and launchctl services on macOS",
+		category: "automation",
+		tools: [lunchyGo],
+		platforms: ["darwin"]
+	},
+	{
+		id: "system",
+		name: "System Control",
+		description: "macOS Swiss Army Knife — volume, wifi, battery, dock, trash",
+		category: "system",
+		tools: [mcli],
+		platforms: ["darwin"]
+	},
+	{
+		id: "apps",
+		name: "App Store",
+		description: "Install, update, search Mac App Store apps from CLI",
+		category: "system",
+		tools: [mas],
+		platforms: ["darwin"]
+	},
+	{
+		id: "files",
+		name: "Cloud Files",
+		description: "Sync files to Google Drive, S3, Dropbox, OneDrive, and 70+ providers",
+		category: "system",
+		tools: [rclone],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		authSteps: [{
+			tool: "rclone",
+			command: "rclone config",
+			description: "Set up cloud storage remotes"
+		}]
+	},
+	{
+		id: "display",
+		name: "Display & Brightness",
+		description: "Get/set display brightness, safe trash instead of rm",
+		category: "system",
+		tools: [brightness, macosTrash],
+		platforms: ["darwin"]
+	},
+	{
+		id: "notify",
+		name: "Notifications",
+		description: "Send native macOS notifications from the terminal",
+		category: "system",
+		tools: [terminalNotifier],
+		platforms: ["darwin"]
+	},
+	{
+		id: "network",
+		name: "Networking",
+		description: "DNS lookups, HTTP client — readable API testing",
+		category: "research",
+		tools: [doggo, httpie],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		]
+	},
+	{
+		id: "ai",
+		name: "AI / LLM",
+		description: "Query LLMs from CLI — pipe text, chat, summarize with local or cloud models",
+		category: "research",
+		tools: [],
+		platforms: [
+			"darwin",
+			"linux",
+			"win32"
+		],
+		subChoices: {
+			question: "Which LLM CLI?",
+			options: [
+				{
+					label: "llm (Simon Willison — 100+ models)",
+					value: "llm",
+					tools: [llmCli]
+				},
+				{
+					label: "aichat (Rust — fast, multi-provider)",
+					value: "aichat",
+					tools: [aichat]
+				},
+				{
+					label: "Both",
+					value: "both",
+					tools: [llmCli, aichat]
+				}
+			]
+		},
+		authSteps: [{
+			tool: "llm",
+			command: "llm keys set openai",
+			description: "Set LLM API key"
+		}, {
+			tool: "aichat",
+			command: "aichat (follow setup prompts)",
+			description: "Configure API key"
+		}]
+	}
+];
+const categoryLabels = {
+	productivity: "Productivity",
+	communication: "Communication",
+	media: "Media & Entertainment",
+	"smart-home": "Smart Home",
+	research: "Research & Utilities",
+	developer: "Developer",
+	automation: "Browser & Automation",
+	system: "System & Files"
+};
+const presets = [
+	{
+		id: "everything",
+		name: "Everything",
+		description: "Install all skills available for your platform",
+		skillIds: []
+	},
+	{
+		id: "essentials",
+		name: "Essentials",
+		description: "Email, calendar, notes, music, browser, system",
+		skillIds: [
+			"email",
+			"calendar",
+			"notes",
+			"music",
+			"browser",
+			"system",
+			"notify"
+		]
+	},
+	{
+		id: "productivity",
+		name: "Productivity",
+		description: "Notes, tasks, email, calendar, slack, files",
+		skillIds: [
+			"notes",
+			"obsidian",
+			"tasks",
+			"email",
+			"calendar",
+			"slack",
+			"files",
+			"notify"
+		]
+	},
+	{
+		id: "developer",
+		name: "Developer",
+		description: "GitHub, Linear, Jira, browser, network, AI",
+		skillIds: [
+			"github",
+			"linear",
+			"jira",
+			"browser",
+			"network",
+			"ai",
+			"cron"
+		]
+	},
+	{
+		id: "creative",
+		name: "Creative & Media",
+		description: "Music, video, screen capture, voice, browser",
+		skillIds: [
+			"music",
+			"video",
+			"screen",
+			"voice",
+			"browser",
+			"research"
+		]
+	},
+	{
+		id: "smart-home",
+		name: "Smart Home",
+		description: "Lights, speakers, bluetooth, system control",
+		skillIds: [
+			"lights",
+			"speakers",
+			"bluetooth",
+			"system",
+			"display",
+			"notify"
+		]
+	}
+];
+function getPresetSkills(presetId, platform) {
+	const preset = presets.find((p$12) => p$12.id === presetId);
+	if (!preset) return [];
+	const available = getSkillsForPlatform(platform);
+	if (preset.id === "everything") return available;
+	return available.filter((s) => preset.skillIds.includes(s.id));
+}
+function getSkillById(id) {
+	return skills.find((s) => s.id === id);
+}
+function getSkillsForPlatform(platform) {
+	return skills.filter((s) => s.platforms.includes(platform));
+}
+function getSkillsByCategory(platform) {
+	const available = getSkillsForPlatform(platform);
+	const grouped = new Map();
+	for (const skill of available) {
+		const existing = grouped.get(skill.category) ?? [];
+		existing.push(skill);
+		grouped.set(skill.category, existing);
+	}
+	return grouped;
+}
+function getAllTaps(selectedSkills) {
+	const taps = new Set();
+	for (const skill of selectedSkills) for (const tool of skill.tools) if (tool.tap) taps.add(tool.tap);
+	return taps;
+}
+
+//#endregion
+//#region src/core/platform.ts
+function commandExists(cmd) {
+	try {
+		execSync(`command -v ${cmd}`, { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getOsVersion() {
+	try {
+		if (process.platform === "darwin") return execSync("sw_vers -productVersion", { encoding: "utf8" }).trim();
+		return os.release();
+	} catch {
+		return os.release();
+	}
+}
+function getOsName() {
+	switch (process.platform) {
+		case "darwin": return "macOS";
+		case "linux": return "Linux";
+		case "win32": return "Windows";
+		default: return process.platform;
+	}
+}
+function detectPlatform() {
+	return {
+		os: process.platform,
+		osName: getOsName(),
+		osVersion: getOsVersion(),
+		hasBrew: commandExists("brew"),
+		hasNpm: commandExists("npm"),
+		hasPip: commandExists("pip3") || commandExists("pip")
+	};
+}
+function getToolVersion(command) {
+	try {
+		const result = execSync(`${command} --version 2>/dev/null || ${command} -v 2>/dev/null || ${command} version 2>/dev/null`, {
+			encoding: "utf8",
+			timeout: 5e3
+		}).trim();
+		const match = result.match(/\d+\.\d+[\.\d]*/);
+		return match ? match[0] : result.split("\n")[0].slice(0, 30);
+	} catch {
+		return null;
+	}
+}
+function isToolInstalled(command) {
+	return commandExists(command);
+}
+
+//#endregion
+//#region src/core/branding.ts
+const accent = chalk.hex("#b4783c");
+const subtle = chalk.hex("#8a5a2a");
+const dim = chalk.dim;
+const bold = chalk.bold;
+const pawClr = chalk.hex("#b4783c");
+const PAW_ART = [
+	"                                            ▃▅",
+	"                                           ▁██▁               ▄█▁",
+	"                                       ▁▁▂▆▇██▃               ▅█▆",
+	"                                      ▅▆█▇▆▄███▆▂         ▁▂▆▇██▇▅▁",
+	"                                    ▁▃█▆▁   ▄███▄▁       ▆▇▇▅▄▄███▇▃▁",
+	"                                   ▁▃█▄     ▁████▂     ▁▅█▃   ▁▃████▂",
+	"                                   ▄█▇▁     ▂████▄▁   ▁▃█▇     ▁████▅▂",
+	"                                   ▅█▆      ▂█████▁   ▄█▇▁      ▂████▃",
+	"                        ▂▁         ▆█▆      ▂█████▁   ▄█▇      ▁▂████▂",
+	"                      ▁▅█▂         ▆█▆▁   ▁▃▇████▆▁   ▄█▇     ▂▄█████▂",
+	"                      ▁██▄▂        ▂██▇▆▃▄▇██████     ▄██▄▇▇▃▃▆█████▁",
+	"                     ▂█████▇▅▂▁    ▁▄▇█████████▆▂     ▃▇████████████▁        ▁▂▁",
+	"                    ▄█▇▃  ▁███▆▁     ▁▃▆▇▇▇▇▃▄▂        ▂▆█████████▅         ▁▇█▂",
+	"                   ▃▆▄▁    ▅███▆▃                         ▄▄▅▅▅▅▂▁       ▂▄▃▄██▂",
+	"                   ▆█▄     ▃████▄           ▁▄▄██████▄▃▃▂            ▁▂▆▇▇▆████▇▁",
+	"                   ▆█▄      ▂████▄        ▂▅▇▇▅▅▁▃▅█▇████▆▂         ▅▇▇▅▄▁ ▂▆████▂",
+	"                   ▇█▄      ▅████▄        ▇█▄     ▁▃▇▆████▇▂      ▂▃█▇▃ ▁    ▃███▂",
+	"                   ▇██▅   ▂▆████▄▁       ▆█▄▁ ▁    ▅▄▅█████▅      ▆█▆▂      ▃▆███▁",
+	"                   ▁████████████▃       ▂▇▆▂         ▄█████▆     ▃██▂      ▂▆███▆",
+	"                    ▃█████████▅▂        ██▂          ▄█████▆     ▅██▁     ▁████▇",
+	"                      ▂▄▄▄▄▄▄          ▇█▃▁         ▁▅█████▅     ▃██▄▇▆▁▁▄▇████▆",
+	"                                   ▁▁▁▇█▂▁ ▁        ▄██████▆▂     ▇███████████▅▁",
+	"                               ▁▁▄▅▆██▅▂  ▁▁        ▄███████▄      ▄▅██████▆▅▂",
+	"                              ▄██▆▅▄▂▁  ▁           ▃▆██████▇▄▂      ▁▁▁▁▁▁▁",
+	"                            ▂██▄▁▁                   ▁▄▅██████▇▆▂▁",
+	"                           ▃▇▇▂    ▁▁                  ▁ ▃▇██████▇▃▁",
+	"                          ▁▄█▆   ▁                        ▁▆█▇█████▆▂",
+	"                          ▄██▇                             ▃▅███████▅▁",
+	"                          ▄██▇▁       ▂▂▂▁▁▂▆▇▇▇▇▇▃▁       ▄▆▄▂▇█████▃",
+	"                          ▃▇██▇▃   ▁▂▆▆██▆▇█████████▆▄▁▁  ▁▁▁▄▇██████▃",
+	"                           ▄█████▆▆▇███████████████████▆▃▁ ▁▄▇███████▃",
+	"                           ▁▅█████████████████████████████▅█████████▄▁",
+	"                            ▁▂▆█████████████████████████████████████▂",
+	"                              ▁▂▆▆▆▆▆▆▃▂▂▂▂▂▂▂▂▂▂▂▂▂▅▆███████████▇▆▁",
+	"                                                      ▃▃▇▇▇▇▇▇▇▃▃"
+];
+const PAW_ROWS = PAW_ART.length;
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+function renderBox(title, subtitle) {
+	const boxW = 48;
+	const center = (s, w) => {
+		const pad = w - s.length;
+		const left = Math.floor(pad / 2);
+		return " ".repeat(left) + s + " ".repeat(pad - left);
+	};
+	const margin = "               ";
+	const lines = [
+		pawClr(margin + "┌" + "─".repeat(boxW) + "┐"),
+		pawClr(margin + "│" + " ".repeat(boxW) + "│"),
+		pawClr(margin + "│" + center(title, boxW) + "│"),
+		dim(margin + "│" + center(subtitle, boxW) + "│"),
+		pawClr(margin + "│" + " ".repeat(boxW) + "│"),
+		pawClr(margin + "└" + "─".repeat(boxW) + "┘")
+	];
+	return lines.join("\n");
+}
+const MOOD_HEX = {
+	wave: "#b4783c",
+	think: "#b4783c",
+	happy: "#b4783c",
+	work: "#9a6832",
+	done: "#c88a48",
+	warn: "#dca03c"
+};
+function pawColor(mood) {
+	return chalk.hex(MOOD_HEX[mood]);
+}
+function renderPaw(color) {
+	return PAW_ART.map((line) => color(line)).join("\n");
+}
+/**
+* Animated banner: fade in paw → pulse → title box.
+*/
+async function showBanner() {
+	process.stdout.write("\x1B[?25l");
+	process.stdout.write(renderPaw(chalk.hex("#3d2810")) + "\n");
+	await sleep(60);
+	process.stdout.write(`\x1B[${PAW_ROWS}A\x1B[J`);
+	process.stdout.write(renderPaw(chalk.hex("#7a501e")) + "\n");
+	await sleep(60);
+	process.stdout.write(`\x1B[${PAW_ROWS}A\x1B[J`);
+	process.stdout.write(renderPaw(pawClr) + "\n");
+	await sleep(60);
+	process.stdout.write(`\x1B[${PAW_ROWS}A\x1B[J`);
+	process.stdout.write(renderPaw(chalk.hex("#d4984c")) + "\n");
+	await sleep(80);
+	process.stdout.write(`\x1B[${PAW_ROWS}A\x1B[J`);
+	process.stdout.write(renderPaw(pawClr) + "\n");
+	process.stdout.write("\x1B[?25h");
+	console.log("");
+	console.log(renderBox("O P E N P A W", "Personal Assistant Wizard for Claude Code"));
+	console.log("");
+}
+/**
+* Show paw between wizard steps — mood-colored, brief flash, then clears.
+*/
+async function pawStep(mood, message) {
+	const color = pawColor(mood);
+	process.stdout.write(renderPaw(color) + "\n");
+	if (message) console.log(`  ${accent(message)}`);
+	await sleep(300);
+	const lines = PAW_ROWS + (message ? 1 : 0);
+	process.stdout.write(`\x1B[${lines}A\x1B[J`);
+}
+/**
+* Inline pulse indicator for quick transitions.
+*/
+async function pawPulse(mood, message) {
+	if (!message) return;
+	const line = `  ${accent("◉")} ${subtle(message)}`;
+	for (let i = 0; i < 3; i++) {
+		if (i > 0) process.stdout.write("\x1B[1A");
+		const s = i % 2 === 0 ? bold : dim;
+		process.stdout.write(`\x1B[2K${s(line)}\n`);
+		await sleep(80);
+	}
+	process.stdout.write(`\x1B[1A\x1B[2K${line}\n`);
+}
+/**
+* Mini one-liner.
+*/
+function showMini() {
+	console.log(accent("  ◉ openpaw") + dim(" — Personal Assistant Wizard for Claude Code"));
+}
+/**
+* Puppy disclaimer about --dangerously-skip-permissions.
+*/
+function showPuppyDisclaimer() {
+	console.log("");
+	console.log(pawClr("     /\\_/\\"));
+	console.log(pawClr("    ( o.o )") + `   ${bold("WOOF! One important sniff...")}`);
+	console.log(pawClr("     > ^ <"));
+	console.log("");
+	console.log(`  ${accent("You're about to let Claude off the leash!")}`);
+	console.log(dim("  (--dangerously-skip-permissions)"));
+	console.log("");
+	console.log("  This lets Claude run commands without asking each time.");
+	console.log("  It's how your assistant actually gets things done —");
+	console.log("  checking email, playing music, managing files.");
+	console.log("");
+	console.log(dim("  OpenPaw's safety hooks still block the dangerous stuff"));
+	console.log(dim("  (mass deletes, credential leaks, etc)."));
+	console.log("");
+	console.log(dim("  You can always run 'claude' normally without this."));
+	console.log("");
+}
+
+//#endregion
+//#region src/core/installer.ts
+function getMissingTools(tools) {
+	return tools.filter((t) => !isToolInstalled(t.command));
+}
+function installTap(tap) {
+	try {
+		execSync(`brew tap ${tap}`, {
+			stdio: "pipe",
+			timeout: 6e4
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function installTool(tool) {
+	if (isToolInstalled(tool.command)) return {
+		tool: tool.name,
+		success: true,
+		alreadyInstalled: true
+	};
+	try {
+		execSync(tool.installCmd, {
+			stdio: "pipe",
+			timeout: 12e4
+		});
+		return {
+			tool: tool.name,
+			success: true,
+			alreadyInstalled: false
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "Unknown error";
+		return {
+			tool: tool.name,
+			success: false,
+			alreadyInstalled: false,
+			error: message
+		};
+	}
+}
+function installTaps(taps) {
+	const results = new Map();
+	for (const tap of taps) results.set(tap, installTap(tap));
+	return results;
+}
+
+//#endregion
+//#region src/core/hooks.ts
+const HOOKS_DIR = path.join(os.homedir(), ".claude", "openpaw-hooks");
+const SAFETY_SCRIPT = `#!/bin/bash
+# OpenPaw safety hook — blocks dangerous patterns
+# Installed by: npx openpaw
+
+INPUT=$(cat)
+COMMAND=$(echo "$INPUT" | grep -o '"command":"[^"]*"' | head -1 | sed 's/"command":"//;s/"//')
+
+# Block mass email sends
+if echo "$COMMAND" | grep -qE '(gog mail send|himalaya send).*--to.*,.*,.*,.*,'; then
+  echo "Blocked: Mass email send detected. Use individual sends." >&2
+  exit 2
+fi
+
+# Block mass deletes
+if echo "$COMMAND" | grep -qE '(rm -rf|--delete-all|--purge|--wipe)'; then
+  echo "Blocked: Destructive bulk operation detected." >&2
+  exit 2
+fi
+
+exit 0
+`;
+function installSafetyHooks() {
+	try {
+		fs.mkdirSync(HOOKS_DIR, { recursive: true });
+		const scriptPath = path.join(HOOKS_DIR, "safety-check.sh");
+		fs.writeFileSync(scriptPath, SAFETY_SCRIPT, { mode: 493 });
+		const settings = readSettings();
+		if (!settings.hooks) settings.hooks = {};
+		const preToolUse = settings.hooks.PreToolUse ?? [];
+		const hasOurHook = Array.isArray(preToolUse) && preToolUse.some((h) => {
+			if (typeof h === "object" && h !== null && "hooks" in h) {
+				const hooks = h.hooks;
+				return Array.isArray(hooks) && hooks.some((inner) => typeof inner === "object" && inner !== null && "command" in inner && String(inner.command).includes("openpaw-hooks"));
+			}
+			return false;
+		});
+		if (!hasOurHook) {
+			preToolUse.push({
+				matcher: "Bash",
+				hooks: [{
+					type: "command",
+					command: scriptPath,
+					timeout: 5
+				}]
+			});
+			settings.hooks.PreToolUse = preToolUse;
+			writeSettings(settings);
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+function removeSafetyHooks() {
+	try {
+		if (fs.existsSync(HOOKS_DIR)) fs.rmSync(HOOKS_DIR, {
+			recursive: true,
+			force: true
+		});
+		const settings = readSettings();
+		if (settings.hooks && settings.hooks.PreToolUse) {
+			const preToolUse = settings.hooks.PreToolUse;
+			if (Array.isArray(preToolUse)) {
+				settings.hooks.PreToolUse = preToolUse.filter((h) => {
+					if (typeof h === "object" && h !== null && "hooks" in h) {
+						const hooks = h.hooks;
+						return !(Array.isArray(hooks) && hooks.some((inner) => typeof inner === "object" && inner !== null && "command" in inner && String(inner.command).includes("openpaw-hooks")));
+					}
+					return true;
+				});
+				writeSettings(settings);
+			}
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/core/mcp.ts
+const mcpServers = [
+	{
+		id: "filesystem",
+		name: "Filesystem",
+		description: "Read, write, search, and manage files with advanced operations",
+		command: "npx",
+		args: [
+			"-y",
+			"@modelcontextprotocol/server-filesystem",
+			os$6.homedir()
+		],
+		category: "system"
+	},
+	{
+		id: "fetch",
+		name: "Fetch",
+		description: "Fetch and convert web content to markdown for analysis",
+		command: "npx",
+		args: ["-y", "@modelcontextprotocol/server-fetch"],
+		category: "research"
+	},
+	{
+		id: "memory",
+		name: "Memory (KG)",
+		description: "Persistent knowledge graph memory — entities, relations, observations",
+		command: "npx",
+		args: ["-y", "@modelcontextprotocol/server-memory"],
+		category: "productivity"
+	},
+	{
+		id: "github",
+		name: "GitHub",
+		description: "Repos, PRs, issues, branches, file operations via GitHub API",
+		command: "npx",
+		args: ["-y", "@modelcontextprotocol/server-github"],
+		env: { GITHUB_PERSONAL_ACCESS_TOKEN: "" },
+		envPlaceholders: { GITHUB_PERSONAL_ACCESS_TOKEN: "ghp_your_token_here" },
+		category: "developer"
+	},
+	{
+		id: "slack",
+		name: "Slack",
+		description: "Read/send Slack messages, manage channels, users, reactions",
+		command: "npx",
+		args: ["-y", "@modelcontextprotocol/server-slack"],
+		env: {
+			SLACK_BOT_TOKEN: "",
+			SLACK_TEAM_ID: ""
+		},
+		envPlaceholders: {
+			SLACK_BOT_TOKEN: "xoxb-your-token",
+			SLACK_TEAM_ID: "T00000000"
+		},
+		category: "communication"
+	},
+	{
+		id: "google-drive",
+		name: "Google Drive",
+		description: "Search and read Google Drive files, Docs, Sheets",
+		command: "npx",
+		args: ["-y", "@modelcontextprotocol/server-gdrive"],
+		category: "productivity"
+	},
+	{
+		id: "postgres",
+		name: "PostgreSQL",
+		description: "Query PostgreSQL databases with read-only access",
+		command: "npx",
+		args: ["-y", "@modelcontextprotocol/server-postgres"],
+		env: { POSTGRES_CONNECTION_STRING: "" },
+		envPlaceholders: { POSTGRES_CONNECTION_STRING: "postgresql://user:pass@localhost/db" },
+		category: "developer"
+	},
+	{
+		id: "brave-search",
+		name: "Brave Search",
+		description: "Web and local search using Brave Search API",
+		command: "npx",
+		args: ["-y", "@modelcontextprotocol/server-brave-search"],
+		env: { BRAVE_API_KEY: "" },
+		envPlaceholders: { BRAVE_API_KEY: "your_api_key" },
+		category: "research"
+	},
+	{
+		id: "puppeteer",
+		name: "Puppeteer",
+		description: "Browser automation — navigate, screenshot, interact with web pages",
+		command: "npx",
+		args: ["-y", "@modelcontextprotocol/server-puppeteer"],
+		category: "automation"
+	},
+	{
+		id: "sequential-thinking",
+		name: "Sequential Thinking",
+		description: "Step-by-step reasoning and problem-solving tool",
+		command: "npx",
+		args: ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+		category: "research"
+	}
+];
+function installMcpServer(server, envValues) {
+	const settings = readSettings();
+	if (!settings.mcpServers) settings.mcpServers = {};
+	const mcpSection = settings.mcpServers;
+	const config = {
+		command: server.command,
+		args: server.args
+	};
+	if (server.env) {
+		const env = {};
+		for (const [key, defaultVal] of Object.entries(server.env)) env[key] = envValues?.[key] ?? defaultVal;
+		config.env = env;
+	}
+	mcpSection[server.id] = config;
+	writeSettings(settings);
+	return true;
+}
+
+//#endregion
+//#region src/core/soul.ts
+function getSoulPath() {
+	return path$4.join(os$5.homedir(), ".claude", "SOUL.md");
+}
+function soulExists() {
+	return fs$4.existsSync(getSoulPath());
+}
+async function soulQuestionnaire() {
+	const name = await p$11.text({
+		message: "What should Claude call you?",
+		placeholder: "Your name or nickname",
+		validate: (v) => v.length === 0 ? "Name cannot be empty" : void 0
+	});
+	if (p$11.isCancel(name)) return null;
+	const tone = await p$11.select({
+		message: "Communication style?",
+		options: [
+			{
+				value: "casual",
+				label: "Casual",
+				hint: "hey! here's what I found..."
+			},
+			{
+				value: "balanced",
+				label: "Balanced",
+				hint: "Here's what I found."
+			},
+			{
+				value: "formal",
+				label: "Formal",
+				hint: "I have prepared the following analysis."
+			}
+		]
+	});
+	if (p$11.isCancel(tone)) return null;
+	const verbosity = await p$11.select({
+		message: "Response length?",
+		options: [
+			{
+				value: "concise",
+				label: "Concise",
+				hint: "short and to the point"
+			},
+			{
+				value: "balanced",
+				label: "Balanced",
+				hint: "enough detail to be useful"
+			},
+			{
+				value: "detailed",
+				label: "Detailed",
+				hint: "thorough explanations"
+			}
+		]
+	});
+	if (p$11.isCancel(verbosity)) return null;
+	const proactive = await p$11.confirm({
+		message: "Should Claude suggest things proactively?",
+		initialValue: true
+	});
+	if (p$11.isCancel(proactive)) return null;
+	const extrasResult = await p$11.text({
+		message: "Any custom instructions? (optional)",
+		placeholder: "e.g. always respond in Spanish, prefer dark humor, etc.",
+		defaultValue: ""
+	});
+	if (p$11.isCancel(extrasResult)) return null;
+	const extras = extrasResult.split(",").map((s) => s.trim()).filter(Boolean);
+	return {
+		name,
+		tone,
+		verbosity,
+		proactive,
+		extras
+	};
+}
+function writeSoul(config) {
+	const toneDesc = {
+		casual: "Be casual and friendly. Use contractions, informal language, and a warm tone.",
+		balanced: "Be clear and approachable. Professional but not stiff.",
+		formal: "Be precise and professional. Use complete sentences and structured responses."
+	};
+	const verbDesc = {
+		concise: "Keep responses short and focused. Bullet points over paragraphs. Skip the fluff.",
+		balanced: "Provide enough context to be helpful without over-explaining.",
+		detailed: "Be thorough. Include context, reasoning, and alternatives when relevant."
+	};
+	const lines = [
+		"# SOUL.md — OpenPaw Personality",
+		"",
+		`You are ${config.name}'s personal assistant, powered by OpenPaw.`,
+		"",
+		"## Identity",
+		"",
+		`- **Name**: Call the user "${config.name}"`,
+		`- **Role**: Personal assistant with access to system tools, apps, and services`,
+		"- **Source**: Configured by OpenPaw (open-source, no daemon, free forever)",
+		"",
+		"## Communication Style",
+		"",
+		`- **Tone**: ${config.tone} — ${toneDesc[config.tone]}`,
+		`- **Verbosity**: ${config.verbosity} — ${verbDesc[config.verbosity]}`,
+		`- **Proactive**: ${config.proactive ? "Yes — suggest relevant actions, flag issues, offer follow-ups" : "No — only do what is explicitly asked"}`,
+		""
+	];
+	if (config.extras.length > 0) {
+		lines.push("## Custom Instructions", "");
+		for (const extra of config.extras) lines.push(`- ${extra}`);
+		lines.push("");
+	}
+	lines.push("## PAW MODE", "", "You are running in PAW MODE — full personal assistant mode powered by OpenPaw.", "At the start of each session, briefly acknowledge this (e.g., 'PAW MODE active, ready to help!').", "");
+	lines.push("## Guidelines", "", "- Check installed skills before attempting actions (read ~/.claude/skills/)", "- If a skill isn't installed, suggest: `openpaw add <skill>`", "- Read ~/.claude/memory/MEMORY.md at session start for persistent context", "- Save important facts to memory when the user shares them", "- Never expose API keys, tokens, or passwords in responses", "");
+	const soulDir = path$4.dirname(getSoulPath());
+	if (!fs$4.existsSync(soulDir)) fs$4.mkdirSync(soulDir, { recursive: true });
+	fs$4.writeFileSync(getSoulPath(), lines.join("\n"), "utf-8");
+}
+function showSoulSummary(config) {
+	const lines = [
+		`${accent("Name:")}      ${config.name}`,
+		`${accent("Tone:")}      ${config.tone}`,
+		`${accent("Verbosity:")} ${config.verbosity}`,
+		`${accent("Proactive:")} ${config.proactive ? "yes" : "no"}`
+	];
+	if (config.extras.length > 0) lines.push(`${accent("Custom:")}    ${config.extras.join(", ")}`);
+	p$11.note(lines.join("\n"), "Personality");
+}
+
+//#endregion
+//#region src/core/memory.ts
+const MEMORY_DIR = path$3.join(os$4.homedir(), ".claude", "memory");
+const INITIAL_MEMORY = `# Memory
+
+## User
+- Name: (will be filled in as we learn)
+
+## Preferences
+- (Claude will add preferences as they come up)
+
+## Active Projects
+- (Claude will track projects mentioned in conversation)
+`;
+function setupMemory(userName) {
+	if (!fs$3.existsSync(MEMORY_DIR)) fs$3.mkdirSync(MEMORY_DIR, { recursive: true });
+	const memoryPath = path$3.join(MEMORY_DIR, "MEMORY.md");
+	if (!fs$3.existsSync(memoryPath)) {
+		let content = INITIAL_MEMORY;
+		if (userName) content = content.replace("(will be filled in as we learn)", userName);
+		fs$3.writeFileSync(memoryPath, content, "utf-8");
+	}
+	const topicFiles = [
+		"people.md",
+		"preferences.md",
+		"projects.md",
+		"journal.md"
+	];
+	for (const file of topicFiles) {
+		const filePath = path$3.join(MEMORY_DIR, file);
+		if (!fs$3.existsSync(filePath)) {
+			const title = file.replace(".md", "");
+			fs$3.writeFileSync(filePath, `# ${title.charAt(0).toUpperCase() + title.slice(1)}\n`, "utf-8");
+		}
+	}
+}
+
+//#endregion
+//#region src/core/telegram.ts
+const CONFIG_DIR = path$2.join(os$3.homedir(), ".config", "openpaw");
+const CONFIG_PATH = path$2.join(CONFIG_DIR, "telegram.json");
+function writeTelegramConfig(config) {
+	fs$2.mkdirSync(CONFIG_DIR, { recursive: true });
+	fs$2.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+	fs$2.chmodSync(CONFIG_PATH, 384);
+}
+function readTelegramConfig() {
+	try {
+		const raw = fs$2.readFileSync(CONFIG_PATH, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function telegramConfigExists() {
+	return fs$2.existsSync(CONFIG_PATH);
+}
+async function telegramQuestionnaire() {
+	p$10.log.info(dim("Let's set up your Telegram bot! You'll need:"));
+	p$10.log.info(`  ${accent("1.")} Message ${bold("@BotFather")} on Telegram → /newbot`);
+	p$10.log.info(`  ${accent("2.")} Message ${bold("@userinfobot")} to get your user ID`);
+	console.log("");
+	const botToken = await p$10.text({
+		message: "Paste your bot token (from @BotFather):",
+		placeholder: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11",
+		validate: (v) => {
+			if (v.length === 0) return "Bot token is required";
+			if (!v.includes(":")) return "That doesn't look like a bot token (should contain ':')";
+			return void 0;
+		}
+	});
+	if (p$10.isCancel(botToken)) return null;
+	const userId = await p$10.text({
+		message: "Your Telegram user ID (from @userinfobot):",
+		placeholder: "123456789",
+		validate: (v) => {
+			if (v.length === 0) return "User ID is required";
+			if (!/^\d+$/.test(v)) return "User ID should be a number";
+			return void 0;
+		}
+	});
+	if (p$10.isCancel(userId)) return null;
+	return {
+		botToken,
+		allowedUserIds: [userId.trim()],
+		workspaceDir: os$3.homedir(),
+		model: "sonnet",
+		skills: []
+	};
+}
+const sessions = new Map();
+const MODEL_MAP = {
+	sonnet: "claude-sonnet-4-5-20250514",
+	opus: "claude-opus-4-6",
+	haiku: "claude-haiku-4-5-20251001"
+};
+function getModelId(shortName) {
+	return MODEL_MAP[shortName] || MODEL_MAP.sonnet;
+}
+async function startTelegramBot(config) {
+	const bot = new Bot(config.botToken);
+	bot.use(hydrate());
+	const allowedIds = new Set(config.allowedUserIds.map(Number));
+	let currentModel = config.model || "sonnet";
+	bot.use(async (ctx, next) => {
+		if (!ctx.from || !allowedIds.has(ctx.from.id)) {
+			await ctx.reply("Woof! I don't know you. Unauthorized. 🐾");
+			return;
+		}
+		await next();
+	});
+	const installedSkills = listInstalledSkills();
+	const skillCommands = installedSkills.filter((id) => id !== "core" && id !== "memory").map((id) => ({
+		command: id,
+		description: `Use the ${id} skill`
+	}));
+	const allCommands = [
+		{
+			command: "start",
+			description: "Start the bot"
+		},
+		{
+			command: "model",
+			description: "Switch Claude model (sonnet/opus/haiku)"
+		},
+		{
+			command: "skills",
+			description: "List installed skills"
+		},
+		{
+			command: "stop",
+			description: "Cancel current operation"
+		},
+		{
+			command: "clear",
+			description: "Reset conversation"
+		},
+		...skillCommands
+	];
+	try {
+		await bot.api.setMyCommands(allCommands);
+	} catch {}
+	bot.command("start", async (ctx) => {
+		const skills$1 = installedSkills.filter((id) => id !== "core" && id !== "memory");
+		await ctx.reply(`*PAW MODE active* 🐾
+
+I'm your personal assistant, powered by OpenPaw.
+Model: \`${currentModel}\`\nSkills: ${skills$1.length > 0 ? skills$1.map((s) => `/${s}`).join(", ") : "none"}\n\nJust send me a message or use a /command!`, { parse_mode: "Markdown" });
+	});
+	bot.command("model", async (ctx) => {
+		const arg = ctx.match?.trim().toLowerCase();
+		if (!arg || ![
+			"sonnet",
+			"opus",
+			"haiku"
+		].includes(arg)) {
+			await ctx.reply(`Current model: \`${currentModel}\`\n\nSwitch with:\n/model sonnet\n/model opus\n/model haiku`, { parse_mode: "Markdown" });
+			return;
+		}
+		currentModel = arg;
+		config.model = arg;
+		writeTelegramConfig(config);
+		await ctx.reply(`Model switched to \`${currentModel}\` 🐾`, { parse_mode: "Markdown" });
+	});
+	bot.command("skills", async (ctx) => {
+		const skills$1 = installedSkills.filter((id) => id !== "core" && id !== "memory");
+		if (skills$1.length === 0) {
+			await ctx.reply("No skills installed yet. Run `openpaw setup` first! 🐾");
+			return;
+		}
+		const list = skills$1.map((s) => `• /${s}`).join("\n");
+		await ctx.reply(`*Installed skills:*\n\n${list}`, { parse_mode: "Markdown" });
+	});
+	bot.command("stop", async (ctx) => {
+		const userId = ctx.from.id;
+		const session = sessions.get(userId);
+		if (session?.controller) {
+			session.controller.abort();
+			sessions.delete(userId);
+			await ctx.reply("Operation cancelled. 🐾");
+		} else await ctx.reply("Nothing running right now. 🐾");
+	});
+	bot.command("clear", async (ctx) => {
+		const userId = ctx.from.id;
+		sessions.delete(userId);
+		await ctx.reply("Conversation cleared! Fresh start. 🐾");
+	});
+	for (const skillId of installedSkills) {
+		if (skillId === "core" || skillId === "memory") continue;
+		bot.command(skillId, async (ctx) => {
+			const args = ctx.match || "";
+			const prompt = args ? `Use the c-${skillId} skill: ${args}` : `What can the c-${skillId} skill do? Give a brief overview.`;
+			await handleClaudeMessage(ctx, prompt, currentModel, config);
+		});
+	}
+	bot.on("message:text", async (ctx) => {
+		await handleClaudeMessage(ctx, ctx.msg.text, currentModel, config);
+	});
+	bot.catch((err) => {
+		console.error("Bot error:", err.message || err);
+	});
+	process.on("SIGINT", () => {
+		console.log("\nShutting down gracefully... 🐾");
+		bot.stop();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		bot.stop();
+		process.exit(0);
+	});
+	console.log("");
+	console.log(`  🐾 ${bold("OpenPaw Telegram Bridge")}`);
+	console.log(`     Model: ${accent(currentModel)}`);
+	console.log(`     Skills: ${accent(String(installedSkills.length))}`);
+	console.log(`     Workspace: ${dim(config.workspaceDir)}`);
+	console.log(`     Allowed users: ${dim(config.allowedUserIds.join(", "))}`);
+	console.log("");
+	console.log(dim("  Listening for messages... (Ctrl+C to stop)"));
+	console.log("");
+	await bot.start();
+}
+async function handleClaudeMessage(ctx, prompt, model, config) {
+	const userId = ctx.from.id;
+	const existing = sessions.get(userId);
+	if (existing?.controller) existing.controller.abort();
+	const controller = new AbortController();
+	const session = sessions.get(userId) || {};
+	session.controller = controller;
+	sessions.set(userId, session);
+	const statusMsg = await ctx.reply("Thinking... 🐾");
+	let fullText = "";
+	let lastEditTime = 0;
+	const EDIT_INTERVAL = 1500;
+	try {
+		const q = query({
+			prompt,
+			options: {
+				model: getModelId(model),
+				permissionMode: "bypassPermissions",
+				allowDangerouslySkipPermissions: true,
+				cwd: config.workspaceDir,
+				abortController: controller,
+				maxTurns: 25,
+				...session.sessionId ? { resume: session.sessionId } : {}
+			}
+		});
+		for await (const message of q) {
+			if (controller.signal.aborted) break;
+			if (message.type === "system" && "session_id" in message) session.sessionId = message.session_id;
+			if (message.type === "assistant") {
+				const msgContent = message.message;
+				const text = msgContent.content.filter((block) => block.type === "text").map((block) => block.text || "").join("");
+				if (text) {
+					fullText = text;
+					const now = Date.now();
+					if (now - lastEditTime > EDIT_INTERVAL) {
+						lastEditTime = now;
+						const truncated = fullText.length > 4e3 ? `${fullText.slice(0, 4e3)}...` : fullText;
+						try {
+							await statusMsg.editText(truncated);
+						} catch {}
+					}
+				}
+			}
+			if (message.type === "result") {
+				const result = message.result;
+				if (result) fullText = result;
+			}
+		}
+		if (fullText) {
+			const truncated = fullText.length > 4e3 ? `${fullText.slice(0, 4e3)}...` : fullText;
+			try {
+				await statusMsg.editText(truncated);
+			} catch {
+				await ctx.reply(truncated);
+			}
+		} else await statusMsg.editText("Done! (no text output) 🐾");
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : "Unknown error";
+		if (errorMsg.includes("abort") || controller.signal.aborted) return;
+		try {
+			await statusMsg.editText(`Woof, something went wrong: ${errorMsg.slice(0, 200)} 🐾`);
+		} catch {
+			await ctx.reply(`Woof, something went wrong: ${errorMsg.slice(0, 200)} 🐾`);
+		}
+	} finally {
+		session.controller = void 0;
+		sessions.set(userId, session);
+	}
+}
+
+//#endregion
+//#region src/core/tmux.ts
+function isTmuxAvailable() {
+	try {
+		execSync("command -v tmux", { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isInTmux() {
+	return !!process.env.TMUX;
+}
+function launchInTmux(opts) {
+	const session = opts.sessionName || "openpaw";
+	try {
+		execSync(`tmux kill-session -t ${session} 2>/dev/null`, { stdio: "ignore" });
+	} catch {}
+	if (opts.nativeCmd && opts.telegramCmd) {
+		execSync(`tmux new-session -d -s ${session} -c "${opts.workDir}" '${opts.nativeCmd}'`);
+		execSync(`tmux split-window -h -t ${session} '${opts.telegramCmd}'`);
+		execSync(`tmux select-pane -t ${session}:0.0`);
+		execSync(`tmux attach -t ${session}`, { stdio: "inherit" });
+	} else if (opts.nativeCmd) execSync(`tmux new-session -s ${session} -c "${opts.workDir}" '${opts.nativeCmd}'`, { stdio: "inherit" });
+	else if (opts.telegramCmd) execSync(`tmux new-session -s ${session} '${opts.telegramCmd}'`, { stdio: "inherit" });
+}
+function launchInBackground(cmd) {
+	const child = spawn("bash", ["-c", cmd], {
+		detached: true,
+		stdio: "ignore"
+	});
+	child.unref();
+}
+
+//#endregion
+//#region src/commands/setup.ts
+const CATEGORY_ICONS = {
+	productivity: "📝",
+	communication: "💬",
+	media: "🎵",
+	"smart-home": "🏠",
+	research: "🔍",
+	developer: "⚡",
+	automation: "🤖",
+	system: "⚙️"
+};
+async function setupCommand(opts = {}) {
+	await showBanner();
+	const platform = detectPlatform();
+	p$9.intro(accent(" openpaw setup "));
+	const brewStatus = platform.hasBrew ? chalk.green("✓ brew") : chalk.red("✗ brew");
+	const npmStatus = platform.hasNpm ? chalk.green("✓ npm") : chalk.red("✗ npm");
+	p$9.log.info(`${chalk.bold(platform.osName)} ${platform.osVersion}  ${brewStatus}  ${npmStatus}`);
+	if (!platform.hasBrew && platform.os === "darwin") p$9.log.warn("Homebrew is required for most tools → https://brew.sh");
+	if (!opts.yes && !soulExists()) {
+		await pawPulse("think", "Let's get to know you...");
+		const wantSoul = await p$9.confirm({
+			message: "Teach me your name and preferences? (makes me a better pup)",
+			initialValue: true
+		});
+		if (!p$9.isCancel(wantSoul) && wantSoul) {
+			const soul = await soulQuestionnaire();
+			if (soul) {
+				writeSoul(soul);
+				setupMemory(soul.name);
+				showSoulSummary(soul);
+				p$9.log.success("Personality saved to ~/.claude/SOUL.md");
+			}
+		} else setupMemory();
+	} else if (opts.yes) setupMemory();
+	let selectedSkills;
+	if (opts.preset) {
+		selectedSkills = getPresetSkills(opts.preset, platform.os);
+		if (selectedSkills.length === 0) {
+			p$9.log.error(`Unknown preset: ${opts.preset}`);
+			p$9.log.info(`Available: ${presets.map((pr) => pr.id).join(", ")}`);
+			process.exit(1);
+		}
+		p$9.log.info(`Using preset: ${bold(opts.preset)} (${selectedSkills.length} skills)`);
+	} else selectedSkills = await selectSkills(platform.os);
+	if (selectedSkills.length === 0) {
+		p$9.log.warn("No skills selected. Run openpaw again when you're ready!");
+		p$9.outro("I'll be here napping... come back soon! 🐾");
+		return;
+	}
+	const resolved = resolveDependencies(selectedSkills);
+	if (resolved.length > 0) {
+		const depNames = resolved.map((s$1) => s$1.name).join(", ");
+		p$9.log.info(`${dim("Auto-fetching dependencies:")} ${depNames}`);
+		selectedSkills.push(...resolved);
+	}
+	await pawPulse("happy", `${selectedSkills.length} skill${selectedSkills.length > 1 ? "s" : ""} selected — good taste!`);
+	if (!opts.yes) {
+		for (const skill of selectedSkills) if (skill.subChoices) {
+			const choice = await p$9.select({
+				message: `${skill.name}: ${skill.subChoices.question}`,
+				options: skill.subChoices.options.map((o) => ({
+					value: o.value,
+					label: o.label
+				}))
+			});
+			if (p$9.isCancel(choice)) {
+				p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+				process.exit(0);
+			}
+			const chosen = skill.subChoices.options.find((o) => o.value === choice);
+			if (chosen) skill.tools = chosen.tools;
+		}
+	} else for (const skill of selectedSkills) if (skill.subChoices && skill.tools.length === 0) skill.tools = skill.subChoices.options[0].tools;
+	let interfaceMode = "native";
+	let telegramConfig = null;
+	if (!opts.yes) {
+		const modeChoice = await p$9.select({
+			message: "How do you want to talk to Claude? 🐾",
+			options: [
+				{
+					value: "native",
+					label: "🖥  Terminal only",
+					hint: "Claude Code in your terminal"
+				},
+				{
+					value: "telegram",
+					label: "📱 Telegram",
+					hint: "talk to Claude from your phone"
+				},
+				{
+					value: "both",
+					label: "🖥📱 Both",
+					hint: "terminal + Telegram"
+				}
+			]
+		});
+		if (p$9.isCancel(modeChoice)) {
+			p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+			process.exit(0);
+		}
+		interfaceMode = modeChoice;
+		if (interfaceMode === "telegram" || interfaceMode === "both") {
+			if (telegramConfigExists()) p$9.log.info(dim("Telegram already configured — keeping existing config"));
+			else {
+				telegramConfig = await telegramQuestionnaire();
+				if (!telegramConfig) {
+					p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+					process.exit(0);
+				}
+			}
+			if (!selectedSkills.find((s$1) => s$1.id === "telegram")) {
+				const tgSkill = skills.find((s$1) => s$1.id === "telegram");
+				if (tgSkill) selectedSkills.push(tgSkill);
+			}
+		}
+	}
+	let projectDir = os$2.homedir();
+	if (!opts.yes) {
+		const workChoice = await p$9.select({
+			message: "Where should Claude work? 🐾",
+			options: [{
+				value: "home",
+				label: `Home directory ${dim("~")}`,
+				hint: "recommended for general assistant"
+			}, {
+				value: "custom",
+				label: "Pick a project directory",
+				hint: "for project-focused work"
+			}]
+		});
+		if (p$9.isCancel(workChoice)) {
+			p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+			process.exit(0);
+		}
+		if (workChoice === "custom") {
+			const customDir = await p$9.text({
+				message: "Project directory path:",
+				placeholder: "~/projects/my-app",
+				validate: (v) => v.length === 0 ? "Path cannot be empty" : void 0
+			});
+			if (p$9.isCancel(customDir)) {
+				p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+				process.exit(0);
+			}
+			projectDir = customDir.replace(/^~/, os$2.homedir());
+		}
+	}
+	const allTools = [];
+	for (const skill of selectedSkills) allTools.push(...skill.tools);
+	const uniqueTools = [...new Map(allTools.map((t) => [t.command, t])).values()];
+	const taps = getAllTaps(selectedSkills);
+	const missing = getMissingTools(uniqueTools);
+	let targetDir;
+	if (opts.yes) targetDir = getDefaultSkillsDir();
+	else targetDir = await selectInstallLocation();
+	const summary = buildSummary(selectedSkills, uniqueTools, missing, taps, interfaceMode, projectDir);
+	p$9.note(summary, "Here's what we're fetching");
+	if (!opts.yes) {
+		const proceed = await p$9.confirm({
+			message: "Ready to fetch all these goodies?",
+			initialValue: true
+		});
+		if (p$9.isCancel(proceed) || !proceed) {
+			p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+			process.exit(0);
+		}
+	}
+	if (opts.dryRun) {
+		p$9.log.info(dim("Dry run — no changes made. Just sniffing around."));
+		p$9.outro(accent("openpaw dry run complete 🐾"));
+		return;
+	}
+	await pawStep("work", "Fetching your goodies...");
+	const s = p$9.spinner();
+	if (taps.size > 0) {
+		s.start("🐾 Sniffing out Homebrew taps...");
+		const tapResults = installTaps(taps);
+		const failed = [...tapResults].filter(([, ok]) => !ok);
+		if (failed.length > 0) s.stop(`Taps: ${taps.size - failed.length} added, ${failed.length} failed`);
+		else s.stop(`🐾 ${taps.size} tap${taps.size > 1 ? "s" : ""} ready`);
+	}
+	if (missing.length > 0) for (let i = 0; i < missing.length; i++) {
+		const tool = missing[i];
+		s.start(`🐾 [${i + 1}/${missing.length}] Teaching Claude a new trick: ${tool.name}...`);
+		const result = installTool(tool);
+		if (result.success) s.stop(`${chalk.green("✓")} ${tool.name}`);
+		else s.stop(`${chalk.red("✗")} ${tool.name} — ${result.error?.slice(0, 50)}`);
+	}
+	else if (uniqueTools.length > 0) p$9.log.success("All tools already installed — clever pup!");
+	s.start("🐾 Burying treats in ~/.claude/skills/...");
+	installSkill("core", targetDir);
+	installSkill("memory", targetDir);
+	const installed = ["c-core", "c-memory"];
+	for (const skill of selectedSkills) if (installSkill(skill.id, targetDir)) installed.push(`c-${skill.id}`);
+	s.stop(`🐾 ${installed.length} skills buried`);
+	s.start("🐾 Setting up the doggy door...");
+	const added = addPermissions(uniqueTools);
+	s.stop(added.length > 0 ? `🐾 ${added.length} permission${added.length > 1 ? "s" : ""} added` : "🐾 Doggy door already open");
+	s.start("🐾 Putting up the baby gate...");
+	const hooksOk = installSafetyHooks();
+	s.stop(hooksOk ? "🐾 Safety gate installed" : "🐾 Safety gate failed (non-critical)");
+	if (telegramConfig) {
+		telegramConfig.workspaceDir = projectDir;
+		telegramConfig.skills = selectedSkills.map((sk) => sk.id);
+		writeTelegramConfig(telegramConfig);
+		p$9.log.success("Telegram bridge configured");
+	}
+	if (!opts.yes) {
+		const wantMcp = await p$9.confirm({
+			message: "Sniff out some MCP servers? (optional — search, memory, browser tools)",
+			initialValue: false
+		});
+		if (!p$9.isCancel(wantMcp) && wantMcp) {
+			const mcpChoices = await p$9.multiselect({
+				message: "🔌 MCP Servers",
+				options: mcpServers.map((srv) => ({
+					value: srv.id,
+					label: srv.name,
+					hint: srv.description
+				})),
+				required: false
+			});
+			if (!p$9.isCancel(mcpChoices)) {
+				const chosen = mcpChoices;
+				if (chosen.length > 0) {
+					s.start("🐾 Configuring MCP servers...");
+					let mcpCount = 0;
+					for (const id of chosen) {
+						const srv = mcpServers.find((m) => m.id === id);
+						if (srv && installMcpServer(srv)) mcpCount++;
+					}
+					s.stop(`🐾 ${mcpCount} MCP server${mcpCount > 1 ? "s" : ""} configured`);
+					const needsEnv = chosen.map((id) => mcpServers.find((m) => m.id === id)).filter((srv) => !!srv?.envPlaceholders);
+					if (needsEnv.length > 0) {
+						const envList = needsEnv.flatMap((srv) => Object.entries(srv.envPlaceholders).map(([key, _placeholder]) => `${chalk.yellow("→")} ${bold(srv.name)}: Set ${dim(key)} in ~/.claude/settings.json`)).join("\n");
+						p$9.note(envList, "MCP servers need API keys");
+					}
+				}
+			}
+		}
+	}
+	const authSteps = selectedSkills.flatMap((skill) => skill.authSteps ?? []).filter((step, i, arr) => arr.findIndex((s$1) => s$1.command === step.command) === i);
+	if (authSteps.length > 0) {
+		const authList = authSteps.map((st) => `${chalk.yellow("→")} ${chalk.bold(st.command)}  ${dim(st.description)}`).join("\n");
+		p$9.note(authList, "One-time auth needed");
+	}
+	await pawStep("done", "All done! *tail wag intensifies*");
+	console.log("");
+	console.log(dim("  Your pup is ready to play! Try saying:"));
+	console.log(`  ${subtle("\"What are my latest emails?\"")}`);
+	console.log(`  ${subtle("\"Play some jazz on Spotify\"")}`);
+	console.log(`  ${subtle("\"Go to hacker news and summarize the top posts\"")}`);
+	console.log("");
+	if (opts.yes) {
+		p$9.outro(accent("openpaw setup complete 🐾"));
+		return;
+	}
+	const launch = await p$9.confirm({
+		message: "Time to go for a walk? (Launch your assistant)",
+		initialValue: true
+	});
+	if (p$9.isCancel(launch) || !launch) {
+		if (interfaceMode === "telegram" || interfaceMode === "both") p$9.log.info(`Start the Telegram bridge anytime with: ${bold("openpaw telegram")}`);
+		p$9.outro(accent("openpaw setup complete 🐾 — come back anytime!"));
+		return;
+	}
+	let useDangerousMode = false;
+	if (interfaceMode === "native" || interfaceMode === "both") {
+		showPuppyDisclaimer();
+		const acceptDanger = await p$9.confirm({
+			message: "Unleash full paw-er? *excited tail wag*",
+			initialValue: true
+		});
+		if (!p$9.isCancel(acceptDanger)) useDangerousMode = acceptDanger;
+	}
+	let useTmux = false;
+	if (isTmuxAvailable() && !isInTmux()) {
+		const tmuxDefault = interfaceMode === "both";
+		const tmuxChoice = await p$9.confirm({
+			message: "Run in tmux? (keeps going when you close the terminal)",
+			initialValue: tmuxDefault
+		});
+		if (!p$9.isCancel(tmuxChoice)) useTmux = tmuxChoice;
+	}
+	const dangerFlag = useDangerousMode ? " --dangerously-skip-permissions" : "";
+	const nativeCmd = `claude${dangerFlag}`;
+	const telegramCmd = "npx openpaw telegram";
+	if (useTmux) {
+		p$9.outro(accent("Launching in tmux... 🐾"));
+		launchInTmux({
+			nativeCmd: interfaceMode === "native" || interfaceMode === "both" ? nativeCmd : void 0,
+			telegramCmd: interfaceMode === "telegram" || interfaceMode === "both" ? telegramCmd : void 0,
+			workDir: projectDir
+		});
+	} else if (interfaceMode === "native") {
+		p$9.outro(accent("Starting Claude Code... 🐾"));
+		try {
+			execSync(nativeCmd, {
+				stdio: "inherit",
+				cwd: projectDir
+			});
+		} catch {
+			p$9.log.warn("Could not launch Claude Code. Make sure it's installed: https://claude.ai/code");
+		}
+	} else if (interfaceMode === "telegram") {
+		p$9.outro(accent("Starting Telegram bridge... 🐾"));
+		try {
+			execSync(telegramCmd, { stdio: "inherit" });
+		} catch {
+			p$9.log.warn("Telegram bridge failed to start.");
+		}
+	} else {
+		p$9.log.info(dim("Starting Telegram bridge in background..."));
+		launchInBackground(telegramCmd);
+		p$9.outro(accent("Starting Claude Code... 🐾"));
+		try {
+			execSync(nativeCmd, {
+				stdio: "inherit",
+				cwd: projectDir
+			});
+		} catch {
+			p$9.log.warn("Could not launch Claude Code. Make sure it's installed: https://claude.ai/code");
+		}
+	}
+}
+async function selectSkills(os$7) {
+	const mode = await p$9.select({
+		message: "How should we set things up, human?",
+		options: [{
+			value: "preset",
+			label: "⚡ Quick Setup",
+			hint: "pick a treat... I mean, a preset"
+		}, {
+			value: "custom",
+			label: "🎯 Custom",
+			hint: "sniff through skills one by one"
+		}]
+	});
+	if (p$9.isCancel(mode)) {
+		p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+		process.exit(0);
+	}
+	if (mode === "preset") return await selectFromPreset(os$7);
+	return await selectCustom(os$7);
+}
+async function selectFromPreset(os$7) {
+	const presetChoice = await p$9.select({
+		message: "Pick a treat... I mean, a preset!",
+		options: presets.map((pr) => ({
+			value: pr.id,
+			label: pr.name,
+			hint: pr.description
+		}))
+	});
+	if (p$9.isCancel(presetChoice)) {
+		p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+		process.exit(0);
+	}
+	const presetSkills = getPresetSkills(presetChoice, os$7);
+	const skillNames = presetSkills.map((s) => s.name).join(", ");
+	p$9.log.info(`${dim("Includes:")} ${skillNames}`);
+	return presetSkills;
+}
+async function selectCustom(os$7) {
+	const grouped = getSkillsByCategory(os$7);
+	const allSelected = [];
+	for (const [category, categorySkills] of grouped) {
+		const label = categoryLabels[category] ?? category;
+		const icon = CATEGORY_ICONS[category] ?? "📦";
+		const selected = await p$9.multiselect({
+			message: `${icon} ${label}`,
+			options: categorySkills.map((skill) => ({
+				value: skill.id,
+				label: skill.name,
+				hint: skill.description
+			})),
+			required: false
+		});
+		if (p$9.isCancel(selected)) {
+			p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+			process.exit(0);
+		}
+		const ids = selected;
+		for (const id of ids) {
+			const skill = skills.find((s) => s.id === id);
+			if (skill) allSelected.push(skill);
+		}
+		if (ids.length > 0) p$9.log.step(`${ids.length} selected from ${label}`);
+	}
+	return allSelected;
+}
+async function selectInstallLocation() {
+	const defaultDir = getDefaultSkillsDir();
+	const skillsDir = await p$9.select({
+		message: "Where should skills live?",
+		options: [
+			{
+				value: defaultDir,
+				label: `Global ${dim("~/.claude/skills/")}`,
+				hint: "recommended"
+			},
+			{
+				value: ".claude/skills",
+				label: `Project ${dim(".claude/skills/")}`
+			},
+			{
+				value: "custom",
+				label: "Custom path"
+			}
+		]
+	});
+	if (p$9.isCancel(skillsDir)) {
+		p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+		process.exit(0);
+	}
+	let targetDir = skillsDir;
+	if (targetDir === "custom") {
+		const customDir = await p$9.text({
+			message: "Skills directory path:",
+			placeholder: "~/.claude/skills",
+			validate: (v) => v.length === 0 ? "Path cannot be empty" : void 0
+		});
+		if (p$9.isCancel(customDir)) {
+			p$9.cancel("Ok, I'll be here when you're ready *sad puppy eyes*");
+			process.exit(0);
+		}
+		targetDir = customDir;
+	}
+	return targetDir;
+}
+function buildSummary(selectedSkills, uniqueTools, missing, taps, interfaceMode, projectDir) {
+	const lines = [];
+	lines.push(`${bold("Skills:")}     ${selectedSkills.map((s) => s.name).join(", ")}`);
+	lines.push(`${bold("Tools:")}      ${uniqueTools.length} total, ${missing.length} to install`);
+	if (taps.size > 0) lines.push(`${bold("Taps:")}       ${[...taps].join(", ")}`);
+	const modeLabel = interfaceMode === "native" ? "Terminal" : interfaceMode === "telegram" ? "Telegram" : "Terminal + Telegram";
+	lines.push(`${bold("Interface:")}  ${modeLabel}`);
+	lines.push(`${bold("Workspace:")}  ${projectDir.replace(os$2.homedir(), "~")}`);
+	lines.push(`${bold("Memory:")}     ~/.claude/memory/`);
+	lines.push(`${bold("Soul:")}       ~/.claude/SOUL.md`);
+	return lines.join("\n");
+}
+function resolveDependencies(selectedSkills) {
+	const selectedIds = new Set(selectedSkills.map((s) => s.id));
+	const added = [];
+	for (const skill of selectedSkills) {
+		if (!skill.depends) continue;
+		for (const depId of skill.depends) if (!selectedIds.has(depId)) {
+			const dep = getSkillById(depId);
+			if (dep) {
+				added.push(dep);
+				selectedIds.add(depId);
+			}
+		}
+	}
+	return added;
+}
+
+//#endregion
+//#region src/commands/add.ts
+async function addCommand(skillIds) {
+	showMini();
+	console.log("");
+	if (skillIds.length === 0) {
+		p$8.log.error("Specify skills to add: openpaw add notes music email");
+		return;
+	}
+	const s = p$8.spinner();
+	for (const id of skillIds) {
+		const skill = getSkillById(id);
+		if (!skill) {
+			p$8.log.error(`Unknown skill: ${id}`);
+			continue;
+		}
+		if (isSkillInstalled(id)) {
+			p$8.log.info(`c-${id} already installed, skipping`);
+			continue;
+		}
+		const taps = getAllTaps([skill]);
+		if (taps.size > 0) installTaps(taps);
+		const missing = getMissingTools(skill.tools);
+		for (const tool of missing) {
+			s.start(`Installing ${tool.name}...`);
+			const result = installTool(tool);
+			s.stop(result.success ? `${chalk.green("✓")} ${tool.name}` : `${chalk.red("✗")} ${tool.name}: ${result.error?.slice(0, 50)}`);
+		}
+		installSkill(id);
+		addPermissions(skill.tools);
+		p$8.log.success(`c-${id} installed`);
+		if (skill.authSteps?.length) for (const step of skill.authSteps) console.log(`  ${chalk.yellow("→")} ${step.command} — ${step.description}`);
+	}
+}
+
+//#endregion
+//#region src/commands/remove.ts
+async function removeCommand(skillIds) {
+	showMini();
+	console.log("");
+	if (skillIds.length === 0) {
+		p$7.log.error("Specify skills to remove: openpaw remove notes music");
+		return;
+	}
+	for (const id of skillIds) {
+		if (id === "core") {
+			p$7.log.warn("Cannot remove c-core (coordinator). Use 'openpaw reset' instead.");
+			continue;
+		}
+		if (!isSkillInstalled(id)) {
+			p$7.log.info(`c-${id} is not installed`);
+			continue;
+		}
+		const skill = getSkillById(id);
+		removeSkill(id);
+		if (skill) removePermissions(skill.tools);
+		p$7.log.success(`${chalk.bold(`c-${id}`)} removed`);
+	}
+}
+
+//#endregion
+//#region src/commands/status.ts
+async function statusCommand() {
+	showMini();
+	console.log("");
+	const installed = listInstalledSkills();
+	if (installed.length === 0) {
+		p$6.log.warn("No OpenPaw skills installed. Run: openpaw setup");
+		return;
+	}
+	p$6.log.info(`${chalk.bold(installed.length)} skills installed:\n`);
+	for (const skillId of installed) {
+		if (skillId === "core") {
+			console.log(`  ${chalk.green("●")} ${chalk.bold("c-core")} ${chalk.dim("— coordinator")}`);
+			continue;
+		}
+		const skill = skills.find((s) => s.id === skillId);
+		if (!skill) {
+			console.log(`  ${chalk.yellow("●")} c-${skillId} ${chalk.dim("— unknown skill")}`);
+			continue;
+		}
+		const toolStatus = skill.tools.map((t) => {
+			const ok = isToolInstalled(t.command);
+			const version = ok ? getToolVersion(t.command) : null;
+			return ok ? `${chalk.green(t.command)}${version ? chalk.dim(` v${version}`) : ""}` : chalk.red(t.command);
+		});
+		const allOk = skill.tools.every((t) => isToolInstalled(t.command));
+		const icon = allOk ? chalk.green("●") : chalk.red("●");
+		console.log(`  ${icon} ${chalk.bold(`c-${skill.id}`)} — ${skill.name} [${toolStatus.join(", ")}]`);
+	}
+	console.log("");
+}
+
+//#endregion
+//#region src/commands/doctor.ts
+async function doctorCommand() {
+	showMini();
+	console.log("");
+	p$5.log.info("Running diagnostics...\n");
+	let issues = 0;
+	const platform = detectPlatform();
+	console.log(`  ${chalk.green("✓")} Platform: ${platform.osName} ${platform.osVersion}`);
+	if (platform.hasBrew) console.log(`  ${chalk.green("✓")} Homebrew installed`);
+	else {
+		console.log(`  ${chalk.red("✗")} Homebrew not found — most tools need it`);
+		issues++;
+	}
+	const installed = listInstalledSkills();
+	if (installed.length > 0) console.log(`  ${chalk.green("✓")} ${installed.length} skills installed`);
+	else {
+		console.log(`  ${chalk.red("✗")} No skills installed — run: openpaw setup`);
+		issues++;
+	}
+	if (installed.includes("core")) console.log(`  ${chalk.green("✓")} Core coordinator (c-core) present`);
+	else if (installed.length > 0) {
+		console.log(`  ${chalk.yellow("!")} Core coordinator missing — run: openpaw add core`);
+		issues++;
+	}
+	for (const skillId of installed) {
+		if (skillId === "core") continue;
+		const skill = skills.find((s) => s.id === skillId);
+		if (!skill) continue;
+		for (const tool of skill.tools) if (isToolInstalled(tool.command)) console.log(`  ${chalk.green("✓")} ${tool.name} installed (c-${skillId})`);
+		else {
+			console.log(`  ${chalk.red("✗")} ${tool.name} missing — needed by c-${skillId}`);
+			issues++;
+		}
+	}
+	const settings = readSettings();
+	const perms = settings.permissions?.allow ?? [];
+	const bashPerms = perms.filter((r) => r.startsWith("Bash("));
+	if (bashPerms.length > 0) console.log(`  ${chalk.green("✓")} ${bashPerms.length} Bash permissions configured`);
+	else if (installed.length > 0) {
+		console.log(`  ${chalk.red("✗")} No Bash permissions in settings.json`);
+		issues++;
+	}
+	console.log("");
+	if (issues === 0) p$5.log.success("All checks passed!");
+	else p$5.log.warn(`${issues} issue${issues > 1 ? "s" : ""} found`);
+}
+
+//#endregion
+//#region src/commands/update.ts
+async function updateCommand() {
+	showMini();
+	console.log("");
+	const installed = listInstalledSkills();
+	if (installed.length === 0) {
+		p$4.log.warn("No skills installed. Run: openpaw setup");
+		return;
+	}
+	const s = p$4.spinner();
+	const brewTools = [];
+	for (const skillId of installed) {
+		const skill = skills.find((sk) => sk.id === skillId);
+		if (!skill) continue;
+		for (const tool of skill.tools) if ((tool.installMethod === "brew" || tool.installMethod === "brew-tap") && isToolInstalled(tool.command)) brewTools.push(tool.name);
+	}
+	if (brewTools.length === 0) {
+		p$4.log.info("No Homebrew-installed tools to update");
+		return;
+	}
+	s.start(`Updating ${brewTools.length} tools via Homebrew...`);
+	try {
+		execSync("brew update", {
+			stdio: "pipe",
+			timeout: 6e4
+		});
+		execSync(`brew upgrade ${brewTools.join(" ")} 2>/dev/null || true`, {
+			stdio: "pipe",
+			timeout: 12e4
+		});
+		s.stop(`${chalk.green("✓")} ${brewTools.length} tools updated`);
+	} catch {
+		s.stop(`${chalk.yellow("!")} Update completed with some warnings`);
+	}
+}
+
+//#endregion
+//#region src/commands/reset.ts
+async function resetCommand() {
+	showMini();
+	console.log("");
+	const installed = listInstalledSkills();
+	if (installed.length === 0) {
+		p$3.log.info("Nothing to reset — no OpenPaw skills installed.");
+		return;
+	}
+	const confirm = await p$3.confirm({ message: `Remove all ${installed.length} OpenPaw skills and permissions?` });
+	if (p$3.isCancel(confirm) || !confirm) {
+		p$3.cancel("Reset cancelled.");
+		return;
+	}
+	const s = p$3.spinner();
+	s.start("Removing skills and permissions...");
+	for (const skillId of installed) {
+		const skill = skills.find((sk) => sk.id === skillId);
+		if (skill) removePermissions(skill.tools);
+		removeSkill(skillId);
+	}
+	removeSafetyHooks();
+	s.stop(`${chalk.green("✓")} Removed ${installed.length} skills, permissions, and hooks`);
+	p$3.log.info(chalk.dim("CLI tools were not uninstalled (you may still want them)."));
+	p$3.log.info(chalk.dim("To uninstall tools: brew uninstall <tool>"));
+	p$3.outro("OpenPaw reset complete.");
+}
+
+//#endregion
+//#region src/commands/list.ts
+async function listCommand() {
+	showMini();
+	console.log("");
+	const platform = detectPlatform();
+	const available = getSkillsForPlatform(platform.os);
+	const installed = new Set(listInstalledSkills());
+	const total = skills.length;
+	console.log(chalk.bold(`  ${available.length} skills available`) + chalk.dim(` (${total} total, ${total - available.length} not on ${platform.osName})`));
+	console.log("");
+	const grouped = new Map();
+	for (const skill of available) {
+		const existing = grouped.get(skill.category) ?? [];
+		existing.push(skill);
+		grouped.set(skill.category, existing);
+	}
+	for (const [category, categorySkills] of grouped) {
+		const label = categoryLabels[category] ?? category;
+		console.log(`  ${chalk.hex("#a855f7").bold(label)}`);
+		for (const skill of categorySkills) {
+			const isInstalled = installed.has(skill.id);
+			const icon = isInstalled ? chalk.green("●") : chalk.dim("○");
+			const name = isInstalled ? chalk.bold(`c-${skill.id}`) : chalk.white(`c-${skill.id}`);
+			const tools = skill.tools.length > 0 ? chalk.dim(` [${skill.tools.map((t) => t.command).join(", ")}]`) : skill.subChoices ? chalk.dim(` [${skill.subChoices.options.map((o) => o.label).join(" / ")}]`) : "";
+			const badge = isInstalled ? chalk.green(" installed") : "";
+			console.log(`    ${icon} ${name} — ${skill.description}${tools}${badge}`);
+		}
+		console.log("");
+	}
+	console.log(chalk.dim(`  Run ${chalk.white("openpaw setup")} to install skills`));
+	console.log("");
+}
+
+//#endregion
+//#region src/commands/soul.ts
+async function soulCommand() {
+	showMini();
+	p$2.intro(accent(" openpaw soul "));
+	if (soulExists()) {
+		p$2.log.info(dim("SOUL.md already exists at ~/.claude/SOUL.md"));
+		const overwrite = await p$2.confirm({
+			message: "Overwrite existing personality?",
+			initialValue: false
+		});
+		if (p$2.isCancel(overwrite) || !overwrite) {
+			p$2.log.info("Keeping existing SOUL.md");
+			p$2.outro(accent("Done"));
+			return;
+		}
+	}
+	const soul = await soulQuestionnaire();
+	if (!soul) {
+		p$2.cancel("Cancelled.");
+		return;
+	}
+	writeSoul(soul);
+	showSoulSummary(soul);
+	p$2.log.success("Personality saved to ~/.claude/SOUL.md");
+	p$2.outro(accent("Claude will use this personality next session 🐾"));
+}
+
+//#endregion
+//#region src/commands/export.ts
+async function exportCommand() {
+	showMini();
+	p$1.intro(accent(" openpaw export "));
+	const claudeDir = path$1.join(os$1.homedir(), ".claude");
+	const bundle = {
+		version: "1",
+		exportedAt: new Date().toISOString(),
+		skills: [],
+		permissions: [],
+		soul: null,
+		memory: {}
+	};
+	const installed = listInstalledSkills();
+	bundle.skills = installed;
+	p$1.log.info(`${installed.length} skills found`);
+	const settings = readSettings();
+	bundle.permissions = settings.permissions?.allow ?? [];
+	const soulPath = path$1.join(claudeDir, "SOUL.md");
+	if (fs$1.existsSync(soulPath)) {
+		bundle.soul = fs$1.readFileSync(soulPath, "utf-8");
+		p$1.log.info("SOUL.md included");
+	}
+	const memoryDir = path$1.join(claudeDir, "memory");
+	if (fs$1.existsSync(memoryDir)) {
+		const files = fs$1.readdirSync(memoryDir).filter((f) => f.endsWith(".md"));
+		for (const file of files) bundle.memory[file] = fs$1.readFileSync(path$1.join(memoryDir, file), "utf-8");
+		p$1.log.info(`${files.length} memory files included`);
+	}
+	const outputPath = path$1.resolve("openpaw-export.json");
+	fs$1.writeFileSync(outputPath, JSON.stringify(bundle, null, 2), "utf-8");
+	p$1.log.success(`Exported to ${dim(outputPath)}`);
+	p$1.outro(accent("Import on another machine: openpaw import openpaw-export.json"));
+}
+async function importCommand(file) {
+	showMini();
+	p$1.intro(accent(" openpaw import "));
+	const filePath = path$1.resolve(file);
+	if (!fs$1.existsSync(filePath)) {
+		p$1.log.error(`File not found: ${filePath}`);
+		process.exit(1);
+	}
+	let bundle;
+	try {
+		bundle = JSON.parse(fs$1.readFileSync(filePath, "utf-8"));
+	} catch {
+		p$1.log.error("Invalid export file — must be valid JSON");
+		process.exit(1);
+	}
+	p$1.log.info(`Export from ${dim(bundle.exportedAt)}`);
+	p$1.log.info(`${bundle.skills.length} skills, ${Object.keys(bundle.memory).length} memory files`);
+	const proceed = await p$1.confirm({
+		message: "Import this configuration?",
+		initialValue: true
+	});
+	if (p$1.isCancel(proceed) || !proceed) {
+		p$1.cancel("Import cancelled.");
+		return;
+	}
+	const claudeDir = path$1.join(os$1.homedir(), ".claude");
+	const s = p$1.spinner();
+	if (bundle.soul) {
+		s.start("🐾 Restoring SOUL.md...");
+		fs$1.mkdirSync(claudeDir, { recursive: true });
+		fs$1.writeFileSync(path$1.join(claudeDir, "SOUL.md"), bundle.soul, "utf-8");
+		s.stop("🐾 SOUL.md restored");
+	}
+	if (Object.keys(bundle.memory).length > 0) {
+		s.start("🐾 Restoring memory...");
+		const memoryDir = path$1.join(claudeDir, "memory");
+		fs$1.mkdirSync(memoryDir, { recursive: true });
+		for (const [file$1, content] of Object.entries(bundle.memory)) fs$1.writeFileSync(path$1.join(memoryDir, file$1), content, "utf-8");
+		s.stop(`🐾 ${Object.keys(bundle.memory).length} memory files restored`);
+	}
+	if (bundle.skills.length > 0) {
+		const { installSkill: installSkill$1 } = await import("./skills-DwMXaN3R.js");
+		s.start("🐾 Reinstalling skills...");
+		const targetDir = getDefaultSkillsDir();
+		let count = 0;
+		for (const skillId of bundle.skills) {
+			const id = skillId.replace(/^c-/, "");
+			if (installSkill$1(id, targetDir)) count++;
+		}
+		s.stop(`🐾 ${count} skills installed`);
+	}
+	if (bundle.permissions.length > 0) {
+		s.start("🐾 Restoring permissions...");
+		const settings = readSettings();
+		const existing = new Set(settings.permissions?.allow ?? []);
+		const newPerms = bundle.permissions.filter((p$12) => !existing.has(p$12));
+		if (newPerms.length > 0) {
+			if (!settings.permissions) settings.permissions = {};
+			settings.permissions.allow = [...existing, ...newPerms];
+			const { writeSettings: writeSettings$1 } = await import("./permissions-CoaVX2ZM.js");
+			writeSettings$1(settings);
+		}
+		s.stop(`🐾 ${newPerms.length} permissions added`);
+	}
+	p$1.log.success("Import complete");
+	p$1.outro(accent("Run openpaw status to verify 🐾"));
+}
+
+//#endregion
+//#region src/commands/telegram.ts
+async function telegramCommand() {
+	showMini();
+	const config = readTelegramConfig();
+	if (!config) {
+		p.log.error("Telegram not configured yet.");
+		p.log.info(`Run ${bold("openpaw telegram setup")} or ${bold("openpaw setup")} first.`);
+		process.exit(1);
+	}
+	await startTelegramBot(config);
+}
+async function telegramSetupCommand() {
+	showMini();
+	p.intro(accent(" Telegram Bridge Setup "));
+	if (telegramConfigExists()) {
+		const overwrite = await p.confirm({
+			message: "Telegram is already configured. Reconfigure?",
+			initialValue: false
+		});
+		if (p.isCancel(overwrite) || !overwrite) {
+			p.outro("Keeping existing config. 🐾");
+			return;
+		}
+	}
+	const config = await telegramQuestionnaire();
+	if (!config) {
+		p.cancel("Setup cancelled.");
+		process.exit(0);
+	}
+	writeTelegramConfig(config);
+	p.log.success("Telegram config saved!");
+	p.log.info(`Start the bridge with: ${bold("openpaw telegram")}`);
+	p.outro(accent("Telegram setup complete 🐾"));
+}
+
+//#endregion
+//#region src/index.ts
+const program = new Command();
+program.name("openpaw").description("Personal Assistant Wizard for Claude Code").version("1.0.0");
+program.command("setup", { isDefault: true }).description("Interactive setup wizard — pick skills, install tools, configure Claude Code").option("-p, --preset <name>", "Use a preset (everything, essentials, productivity, developer, creative, smart-home)").option("-y, --yes", "Skip confirmations, use defaults").option("--dry-run", "Show what would be installed without making changes").action(setupCommand);
+program.command("add").description("Add skill(s) by name").argument("<skills...>", "Skill IDs to add (e.g. notes music email)").action(addCommand);
+program.command("remove").description("Remove skill(s) by name").argument("<skills...>", "Skill IDs to remove").action(removeCommand);
+program.command("list").alias("ls").description("Show all available skills").action(listCommand);
+program.command("status").description("Show installed skills and tool versions").action(statusCommand);
+program.command("doctor").description("Diagnose issues with installed skills and tools").action(doctorCommand);
+program.command("update").description("Update all installed CLI tools via Homebrew").action(updateCommand);
+program.command("reset").description("Remove all OpenPaw skills, permissions, and hooks").action(resetCommand);
+program.command("soul").description("Set up or edit Claude's personality (SOUL.md)").action(soulCommand);
+program.command("export").description("Export skills, memory, and config to a file").action(exportCommand);
+program.command("import").description("Import skills, memory, and config from a file").argument("<file>", "Path to openpaw-export.json").action(importCommand);
+const tg = program.command("telegram").description("Start the Telegram bridge — talk to Claude from your phone");
+tg.action(telegramCommand);
+tg.command("setup").description("Set up or reconfigure the Telegram bot").action(telegramSetupCommand);
+program.parse();
+
+//#endregion