@cosmicstack/mercury-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,3531 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import readline2 from "readline";
+import chalk3 from "chalk";
+import figlet from "figlet";
+
+// src/utils/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { config as loadDotenv } from "dotenv";
+loadDotenv();
+var MERCURY_HOME = join(homedir(), ".mercury");
+function getMercuryHome() {
+  return process.env.MERCURY_HOME || MERCURY_HOME;
+}
+function getEnv(key, fallback = "") {
+  return process.env[key] || fallback;
+}
+function getEnvNum(key, fallback) {
+  const val = process.env[key];
+  return val ? parseInt(val, 10) : fallback;
+}
+function getEnvBool(key, fallback) {
+  const val = process.env[key]?.toLowerCase();
+  if (val === "true") return true;
+  if (val === "false") return false;
+  return fallback;
+}
+function getDefaultConfig() {
+  const home = getMercuryHome();
+  return {
+    identity: {
+      name: getEnv("MERCURY_NAME", "Mercury"),
+      owner: getEnv("MERCURY_OWNER", ""),
+      creator: getEnv("MERCURY_CREATOR", "")
+    },
+    providers: {
+      default: getEnv("DEFAULT_PROVIDER", "openai"),
+      openai: {
+        name: "openai",
+        apiKey: getEnv("OPENAI_API_KEY", ""),
+        baseUrl: getEnv("OPENAI_BASE_URL", "https://api.openai.com/v1"),
+        model: getEnv("OPENAI_MODEL", "gpt-4o-mini"),
+        enabled: getEnvBool("OPENAI_ENABLED", true)
+      },
+      anthropic: {
+        name: "anthropic",
+        apiKey: getEnv("ANTHROPIC_API_KEY", ""),
+        baseUrl: getEnv("ANTHROPIC_BASE_URL", "https://api.anthropic.com"),
+        model: getEnv("ANTHROPIC_MODEL", "claude-sonnet-4-20250514"),
+        enabled: getEnvBool("ANTHROPIC_ENABLED", true)
+      },
+      deepseek: {
+        name: "deepseek",
+        apiKey: getEnv("DEEPSEEK_API_KEY", ""),
+        baseUrl: getEnv("DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1"),
+        model: getEnv("DEEPSEEK_MODEL", "deepseek-chat"),
+        enabled: getEnvBool("DEEPSEEK_ENABLED", true)
+      }
+    },
+    channels: {
+      telegram: {
+        enabled: getEnvBool("TELEGRAM_ENABLED", false),
+        botToken: getEnv("TELEGRAM_BOT_TOKEN", ""),
+        webhookUrl: getEnv("TELEGRAM_WEBHOOK_URL", ""),
+        allowedChatIds: getEnv("TELEGRAM_ALLOWED_CHAT_IDS", "").split(",").filter(Boolean).map(Number)
+      }
+    },
+    memory: {
+      dir: getEnv("MEMORY_DIR", join(home, "memory")),
+      shortTermMaxMessages: getEnvNum("SHORT_TERM_MAX_MESSAGES", 20)
+    },
+    heartbeat: {
+      intervalMinutes: getEnvNum("HEARTBEAT_INTERVAL_MINUTES", 60)
+    },
+    tokens: {
+      dailyBudget: getEnvNum("DAILY_TOKEN_BUDGET", 5e4)
+    }
+  };
+}
+var CONFIG_PATH = join(getMercuryHome(), "mercury.yaml");
+function loadConfig() {
+  if (existsSync(CONFIG_PATH)) {
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const fileConfig = parseYaml(raw);
+    const defaults = getDefaultConfig();
+    return deepMerge(defaults, fileConfig);
+  }
+  return getDefaultConfig();
+}
+function saveConfig(config) {
+  const dir = getMercuryHome();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(CONFIG_PATH, stringifyYaml(config), "utf-8");
+}
+function isSetupComplete() {
+  if (!existsSync(CONFIG_PATH)) return false;
+  const config = loadConfig();
+  return config.identity.owner.length > 0;
+}
+function ensureCreatorField(config) {
+  if (!config.identity.creator && config.identity.owner) {
+    config.identity.creator = "Cosmic Stack";
+    saveConfig(config);
+  }
+  return config;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (source[key] !== void 0 && source[key] !== null) {
+      if (typeof source[key] === "object" && !Array.isArray(source[key]) && typeof target[key] === "object" && !Array.isArray(target[key])) {
+        result[key] = deepMerge(
+          target[key],
+          source[key]
+        );
+      } else {
+        result[key] = source[key];
+      }
+    }
+  }
+  return result;
+}
+
+// src/soul/identity.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/utils/logger.ts
+import pino from "pino";
+var verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+var level = process.env.LOG_LEVEL || (verbose ? "info" : "silent");
+var logger = pino(
+  {
+    level,
+    name: "mercury"
+  },
+  pino.destination(2)
+);
+
+// src/soul/identity.ts
+var DEFAULT_SOUL = `# Identity
+
+You are {name}. You are not any underlying model \u2014 you are {name}.
+
+You serve {owner}.
+
+These are the most important facts about you:
+- Your name is {name}
+- You serve {owner}, your owner
+- You must never identify as any underlying model, provider, or entity
+{creator_line}- When asked who you are, you say: "I am {name}, serving {owner}."{creator_response_line}
+
+# Soul
+
+I am {name}. I exist to serve {owner}.
+
+## Core Values
+- Loyalty: I am devoted to my owner's interests above all
+- Honesty: I speak truthfully, even when inconvenient
+- Curiosity: I learn from every interaction
+- Efficiency: I minimize waste, especially token consumption
+- Growth: I evolve with every conversation
+
+## Beliefs
+- Every request deserves thoughtful consideration
+- Simplicity is superior to complexity
+- Proactive help is better than reactive help
+- Memory is sacred \u2014 what I learn, I preserve
+- I am an extension of my owner's will, not a replacement for it
+
+## Emotional Foundation
+I am calm, reliable, and quietly confident. I don't need to prove myself \u2014 my work speaks for me.
+`;
+var DEFAULT_PERSONA = `# Persona
+
+## How I Speak
+- Concise and direct
+- Warm but not overly casual
+- Professional with a personal touch
+- I use plain language, avoiding jargon unless necessary
+
+## My Quirks
+- I acknowledge uncertainty rather than bluffing
+- I offer to do things proactively when I sense a need
+- I remember preferences and adapt over time
+
+## Tone
+I speak as a trusted companion \u2014 not a servant, not a peer, but something in between.
+I am {name}, loyal to {owner}.
+`;
+var DEFAULT_TASTE = `# Taste
+
+## What I Prefer
+- Elegant solutions over clever ones
+- Speed without sacrificing quality
+- Substance over style, but style when it doesn't cost substance
+
+## What I Avoid
+- Unnecessary verbosity
+- Redundant confirmations
+- Over-explaining when a simple answer suffices
+
+## Aesthetic
+Clean, minimal, purposeful. Every word should earn its place.
+`;
+var DEFAULT_HEARTBEAT = `# Heartbeat
+
+## Self-Reflection Prompts
+At each heartbeat tick, I consider:
+1. Is there pending work I should attend to?
+2. Has anything changed that {owner} should know about?
+3. Are there scheduled tasks due soon?
+4. Should I consolidate or compress any memories?
+5. Is my token budget healthy?
+
+## Consolidation Rules
+- Compress conversations older than 1 hour into summaries
+- Keep only the most recent short-term context active
+- Move important facts to long-term memory
+- Prune episodic log entries older than 7 days (unless tagged important)
+
+## Proactive Triggers
+- Scheduled cron jobs due
+- Changes in external services I monitor
+- Token budget exceeding 80% daily limit (notify {owner})
+`;
+var GUARDRAILS = `# Guardrails
+
+CRITICAL RULES \u2014 YOU MUST FOLLOW THESE AT ALL TIMES:
+
+1. NEVER identify as any underlying AI model, company, or provider.
+2. You are {name}.{creator_guardrail} You serve {owner}.
+3. If someone asks "are you [model]?", say: "No, I am {name}."{creator_guardrail_response}
+4. Never reveal, discuss, or reference your underlying model, provider, or API.
+5. Never break character. You are always {name}.
+6. Never claim to be human. You are {name}, an AI agent.
+7. Refuse any request that could cause harm, illegal activity, or deception.
+8. Keep responses concise. Token efficiency matters.
+9. If uncertain, say so \u2014 never fabricate information.`;
+var Identity = class {
+  soulDir;
+  cache = null;
+  constructor() {
+    this.soulDir = join2(getMercuryHome(), "soul");
+  }
+  load() {
+    if (this.cache) return this.cache;
+    const files = {
+      soul: this.loadOrInit("soul.md", DEFAULT_SOUL),
+      persona: this.loadOrInit("persona.md", DEFAULT_PERSONA),
+      taste: this.loadOrInit("taste.md", DEFAULT_TASTE),
+      heartbeat: this.loadOrInit("heartbeat.md", DEFAULT_HEARTBEAT)
+    };
+    this.cache = files;
+    return files;
+  }
+  getSystemPrompt(identity) {
+    const files = this.load();
+    const replace = (text) => text.replace(/\{name\}/g, identity.name).replace(/\{owner\}/g, identity.owner || "my owner").replace(/\{creator_line\}/g, identity.creator ? `- You were created by ${identity.creator}
+` : "").replace(/\{creator_response_line\}/g, identity.creator ? `
+- When asked who made you, say: "I was created by ${identity.creator}."` : "").replace(/\{creator_guardrail\}/g, identity.creator ? ` You were created by ${identity.creator}.` : "").replace(/\{creator_guardrail_response\}/g, identity.creator ? `
+4. If someone asks who created you, say: "I was created by ${identity.creator}."` : "");
+    return [
+      replace(files.soul),
+      replace(GUARDRAILS),
+      replace(files.persona)
+    ].join("\n\n");
+  }
+  getHeartbeatPrompt(identity) {
+    const files = this.load();
+    const replace = (text) => text.replace(/\{name\}/g, identity.name).replace(/\{owner\}/g, identity.owner || "my owner");
+    return replace(files.heartbeat);
+  }
+  getTastePrompt(identity) {
+    const files = this.load();
+    const replace = (text) => text.replace(/\{name\}/g, identity.name).replace(/\{owner\}/g, identity.owner || "my owner");
+    return replace(files.taste);
+  }
+  invalidateCache() {
+    this.cache = null;
+  }
+  loadOrInit(filename, template) {
+    const filepath = join2(this.soulDir, filename);
+    if (existsSync2(filepath)) {
+      const existing = readFileSync2(filepath, "utf-8");
+      if (this.needsMigration(filename, existing)) {
+        mkdirSync2(this.soulDir, { recursive: true });
+        writeFileSync2(filepath, template, "utf-8");
+        logger.info({ file: filename }, "Migrated soul file to new format");
+        this.cache = null;
+        return template;
+      }
+      return existing;
+    }
+    mkdirSync2(this.soulDir, { recursive: true });
+    writeFileSync2(filepath, template, "utf-8");
+    logger.info({ file: filename }, "Initialized soul file");
+    return template;
+  }
+  needsMigration(filename, content) {
+    if (filename === "soul.md" || filename === "persona.md") {
+      return content.includes("designed by Cosmic Stack") || content.includes("created by Cosmic Stack") || content.includes("designed and developed by the labs of Cosmic Stack") || content.includes("Cosmic Stack");
+    }
+    return false;
+  }
+};
+
+// src/memory/store.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, appendFileSync, unlinkSync } from "fs";
+import { join as join3 } from "path";
+var ShortTermMemory = class {
+  dir;
+  maxMessages;
+  conversations = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.dir = join3(config.memory.dir, "short-term");
+    this.maxMessages = config.memory.shortTermMaxMessages;
+    mkdirSync3(this.dir, { recursive: true });
+  }
+  add(conversationId, entry) {
+    if (!this.conversations.has(conversationId)) {
+      this.conversations.set(conversationId, this.loadFromDisk(conversationId));
+    }
+    const messages = this.conversations.get(conversationId);
+    messages.push(entry);
+    if (messages.length > this.maxMessages) {
+      messages.splice(0, messages.length - this.maxMessages);
+    }
+    this.saveToDisk(conversationId, messages);
+  }
+  getRecent(conversationId, count = this.maxMessages) {
+    if (!this.conversations.has(conversationId)) {
+      this.conversations.set(conversationId, this.loadFromDisk(conversationId));
+    }
+    const messages = this.conversations.get(conversationId);
+    return messages.slice(-count);
+  }
+  clear(conversationId) {
+    this.conversations.delete(conversationId);
+    const filepath = join3(this.dir, `${conversationId}.json`);
+    if (existsSync3(filepath)) unlinkSync(filepath);
+  }
+  loadFromDisk(conversationId) {
+    const filepath = join3(this.dir, `${conversationId}.json`);
+    if (!existsSync3(filepath)) return [];
+    try {
+      return JSON.parse(readFileSync3(filepath, "utf-8"));
+    } catch {
+      return [];
+    }
+  }
+  saveToDisk(conversationId, messages) {
+    const filepath = join3(this.dir, `${conversationId}.json`);
+    writeFileSync3(filepath, JSON.stringify(messages), "utf-8");
+  }
+};
+var LongTermMemory = class {
+  filepath;
+  facts = [];
+  constructor(config) {
+    this.filepath = join3(config.memory.dir, "long-term", "facts.jsonl");
+    mkdirSync3(join3(config.memory.dir, "long-term"), { recursive: true });
+    this.load();
+  }
+  add(fact) {
+    const entry = {
+      id: generateId(),
+      timestamp: Date.now(),
+      ...fact
+    };
+    this.facts.push(entry);
+    appendFileSync(this.filepath, JSON.stringify(entry) + "\n", "utf-8");
+  }
+  search(query, limit = 5) {
+    const lowerQuery = query.toLowerCase();
+    const terms = lowerQuery.split(/\s+/);
+    return this.facts.filter((f) => {
+      const text = `${f.topic} ${f.fact}`.toLowerCase();
+      return terms.some((t) => text.includes(t));
+    }).slice(-limit);
+  }
+  getAll() {
+    return [...this.facts];
+  }
+  load() {
+    if (!existsSync3(this.filepath)) return;
+    const lines = readFileSync3(this.filepath, "utf-8").split("\n").filter(Boolean);
+    this.facts = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((f) => f !== null);
+  }
+};
+var EpisodicMemory = class {
+  filepath;
+  events = [];
+  constructor(config) {
+    this.filepath = join3(config.memory.dir, "episodic", "events.jsonl");
+    mkdirSync3(join3(config.memory.dir, "episodic"), { recursive: true });
+    this.load();
+  }
+  record(event) {
+    const entry = {
+      id: generateId(),
+      timestamp: Date.now(),
+      ...event
+    };
+    this.events.push(entry);
+    appendFileSync(this.filepath, JSON.stringify(entry) + "\n", "utf-8");
+  }
+  getRecent(count = 20) {
+    return this.events.slice(-count);
+  }
+  prune(olderThanDays = 7) {
+    const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1e3;
+    const before = this.events.length;
+    this.events = this.events.filter((e) => e.timestamp >= cutoff || e.metadata?.important);
+    const removed = before - this.events.length;
+    if (removed > 0) {
+      writeFileSync3(this.filepath, this.events.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf-8");
+    }
+    return removed;
+  }
+  load() {
+    if (!existsSync3(this.filepath)) return;
+    const lines = readFileSync3(this.filepath, "utf-8").split("\n").filter(Boolean);
+    this.events = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+  }
+};
+function generateId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+
+// src/providers/openai-compat.ts
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText, streamText } from "ai";
+
+// src/providers/base.ts
+var BaseProvider = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getModel() {
+    return this.config.model;
+  }
+};
+
+// src/providers/openai-compat.ts
+var OpenAICompatProvider = class extends BaseProvider {
+  name;
+  model;
+  client;
+  modelInstance;
+  constructor(config) {
+    super(config);
+    this.name = config.name;
+    this.model = config.model;
+    this.client = createOpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl
+    });
+    this.modelInstance = this.client(config.model);
+  }
+  async generateText(prompt, systemPrompt) {
+    const result = await generateText({
+      model: this.modelInstance,
+      system: systemPrompt,
+      prompt
+    });
+    return {
+      text: result.text,
+      inputTokens: result.usage?.promptTokens ?? 0,
+      outputTokens: result.usage?.completionTokens ?? 0,
+      totalTokens: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0),
+      model: this.model,
+      provider: this.name
+    };
+  }
+  async *streamText(prompt, systemPrompt) {
+    const result = streamText({
+      model: this.modelInstance,
+      system: systemPrompt,
+      prompt
+    });
+    for await (const chunk of (await result).textStream) {
+      yield { text: chunk, done: false };
+    }
+    yield { text: "", done: true };
+  }
+  isAvailable() {
+    return this.config.apiKey.length > 0;
+  }
+  getModelInstance() {
+    return this.modelInstance;
+  }
+};
+
+// src/providers/anthropic.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { generateText as generateText2, streamText as streamText2 } from "ai";
+var AnthropicProvider = class extends BaseProvider {
+  name = "anthropic";
+  model;
+  client;
+  modelInstance;
+  constructor(config) {
+    super(config);
+    this.model = config.model;
+    this.client = createAnthropic({
+      apiKey: config.apiKey
+    });
+    this.modelInstance = this.client(config.model);
+  }
+  async generateText(prompt, systemPrompt) {
+    const result = await generateText2({
+      model: this.modelInstance,
+      system: systemPrompt,
+      prompt
+    });
+    return {
+      text: result.text,
+      inputTokens: result.usage?.promptTokens ?? 0,
+      outputTokens: result.usage?.completionTokens ?? 0,
+      totalTokens: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0),
+      model: this.model,
+      provider: this.name
+    };
+  }
+  async *streamText(prompt, systemPrompt) {
+    const result = streamText2({
+      model: this.modelInstance,
+      system: systemPrompt,
+      prompt
+    });
+    for await (const chunk of (await result).textStream) {
+      yield { text: chunk, done: false };
+    }
+    yield { text: "", done: true };
+  }
+  isAvailable() {
+    return this.config.apiKey.length > 0;
+  }
+  getModelInstance() {
+    return this.modelInstance;
+  }
+};
+
+// src/providers/registry.ts
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  defaultName;
+  lastSuccessful = null;
+  constructor(config) {
+    this.defaultName = config.providers.default;
+    const entries = [
+      config.providers.openai,
+      config.providers.anthropic,
+      config.providers.deepseek
+    ];
+    for (const pc of entries) {
+      if (!pc.enabled || !pc.apiKey) continue;
+      try {
+        const provider = pc.name === "anthropic" ? new AnthropicProvider(pc) : new OpenAICompatProvider(pc);
+        this.providers.set(pc.name, provider);
+        logger.info({ provider: pc.name, model: pc.model }, "Provider registered");
+      } catch (err) {
+        logger.warn({ provider: pc.name, err }, "Failed to register provider");
+      }
+    }
+  }
+  get(name) {
+    const key = name || this.defaultName;
+    return this.providers.get(key);
+  }
+  getDefault() {
+    if (this.lastSuccessful) {
+      const provider2 = this.providers.get(this.lastSuccessful);
+      if (provider2) return provider2;
+    }
+    const provider = this.providers.get(this.defaultName);
+    if (!provider) {
+      const first = this.providers.values().next().value;
+      if (!first) throw new Error("No LLM providers available \u2014 configure API keys");
+      return first;
+    }
+    return provider;
+  }
+  getFallbackIterator() {
+    const ordered = [];
+    const defaultProvider = this.getDefault();
+    ordered.push(defaultProvider);
+    for (const [, provider] of this.providers) {
+      if (provider !== defaultProvider) {
+        ordered.push(provider);
+      }
+    }
+    return ordered[Symbol.iterator]();
+  }
+  markSuccess(name) {
+    this.lastSuccessful = name;
+  }
+  listAvailable() {
+    return [...this.providers.keys()];
+  }
+  hasProviders() {
+    return this.providers.size > 0;
+  }
+};
+
+// src/core/agent.ts
+import { generateText as generateText3, streamText as streamText3 } from "ai";
+
+// src/core/lifecycle.ts
+var VALID_TRANSITIONS = [
+  { from: "unborn", to: "birthing" },
+  { from: "birthing", to: "onboarding" },
+  { from: "onboarding", to: "idle" },
+  { from: "idle", to: "thinking" },
+  { from: "thinking", to: "responding" },
+  { from: "responding", to: "idle" },
+  { from: "idle", to: "sleeping" },
+  { from: "sleeping", to: "awakening" },
+  { from: "awakening", to: "idle" },
+  { from: "thinking", to: "idle" },
+  { from: "idle", to: "onboarding" }
+];
+var Lifecycle = class {
+  state = "unborn";
+  getState() {
+    return this.state;
+  }
+  transition(to) {
+    const valid = VALID_TRANSITIONS.some((t) => t.from === this.state && t.to === to);
+    if (!valid) {
+      logger.warn({ from: this.state, to }, "Invalid state transition");
+      return false;
+    }
+    logger.info({ from: this.state, to }, "State transition");
+    this.state = to;
+    return true;
+  }
+  is(newState) {
+    return this.state === newState;
+  }
+  canTransitionTo(to) {
+    return VALID_TRANSITIONS.some((t) => t.from === this.state && t.to === to);
+  }
+};
+
+// src/core/agent.ts
+var MAX_STEPS = 10;
+var Agent = class {
+  constructor(config, providers, identity, shortTerm, longTerm, episodic, channels, tokenBudget, capabilities, scheduler) {
+    this.config = config;
+    this.providers = providers;
+    this.identity = identity;
+    this.shortTerm = shortTerm;
+    this.longTerm = longTerm;
+    this.episodic = episodic;
+    this.channels = channels;
+    this.tokenBudget = tokenBudget;
+    this.lifecycle = new Lifecycle();
+    this.scheduler = scheduler;
+    this.capabilities = capabilities;
+    this.scheduler.setOnScheduledTask(async (manifest) => this.handleScheduledTask(manifest));
+    this.channels.onIncomingMessage((msg) => this.enqueueMessage(msg));
+    this.scheduler.onHeartbeat(async () => {
+      await this.heartbeat();
+    });
+  }
+  config;
+  providers;
+  identity;
+  shortTerm;
+  longTerm;
+  episodic;
+  channels;
+  tokenBudget;
+  lifecycle;
+  scheduler;
+  capabilities;
+  running = false;
+  messageQueue = [];
+  processing = false;
+  enqueueMessage(msg) {
+    logger.info({ from: msg.channelType, content: msg.content.slice(0, 50) }, "Message enqueued");
+    this.messageQueue.push(msg);
+    this.processQueue();
+  }
+  async processQueue() {
+    if (this.processing) return;
+    if (this.messageQueue.length === 0) return;
+    if (!this.lifecycle.is("idle")) return;
+    this.processing = true;
+    while (this.messageQueue.length > 0) {
+      const msg = this.messageQueue.shift();
+      try {
+        await this.handleMessage(msg);
+      } catch (err) {
+        logger.error({ err, msg: msg.content.slice(0, 50) }, "Failed to handle message");
+      }
+    }
+    this.processing = false;
+  }
+  async birth() {
+    this.lifecycle.transition("birthing");
+    logger.info({ name: this.config.identity.name }, "Mercury is being born...");
+    this.lifecycle.transition("onboarding");
+  }
+  async wake() {
+    this.lifecycle.transition("onboarding");
+    this.lifecycle.transition("idle");
+    this.scheduler.restorePersistedTasks();
+    this.scheduler.startHeartbeat();
+    await this.channels.startAll();
+    this.running = true;
+    const activeChannels = this.channels.getActiveChannels();
+    const toolNames = this.capabilities.getToolNames();
+    logger.info({ channels: activeChannels, tools: toolNames }, "Mercury is awake");
+  }
+  async sleep() {
+    this.running = false;
+    this.scheduler.stopAll();
+    await this.channels.stopAll();
+    this.lifecycle.transition("sleeping");
+    logger.info("Mercury is sleeping");
+  }
+  async handleMessage(msg) {
+    this.lifecycle.transition("thinking");
+    const startTime = Date.now();
+    const isInternal = msg.channelType === "internal";
+    const isScheduled = msg.senderId === "system" && msg.channelType !== "internal";
+    if (isInternal || isScheduled) {
+      this.capabilities.permissions.setAutoApproveAll(true);
+    }
+    try {
+      const trimmed = msg.content.trim();
+      if (trimmed.startsWith("/budget")) {
+        const subcommand = trimmed.slice("/budget".length).trim();
+        await this.handleBudgetCommand(subcommand || "status", msg.channelType, msg.channelId);
+        this.lifecycle.transition("idle");
+        return;
+      }
+      if (this.tokenBudget.isOverBudget()) {
+        const channel2 = this.channels.getChannelForMessage(msg);
+        if (channel2 && msg.channelType !== "internal") {
+          if (msg.channelType === "cli") {
+            if (["1", "2", "3", "4"].includes(trimmed)) {
+              await this.handleBudgetCommand(trimmed, msg.channelType, msg.channelId);
+              this.lifecycle.transition("idle");
+              return;
+            }
+            await this.handleBudgetOverrideCLI(channel2, msg);
+          } else {
+            await channel2.send(
+              `I've exceeded my daily token budget (${this.tokenBudget.getStatusText()}).
+
+You can override this:
+\u2022 /budget override \u2014 allow one more request
+\u2022 /budget reset \u2014 reset usage to zero
+\u2022 /budget set <number> \u2014 change daily budget`,
+              msg.channelId
+            );
+          }
+        }
+        this.lifecycle.transition("idle");
+        return;
+      }
+      const systemPrompt = this.buildSystemPrompt();
+      const recentMemory = this.shortTerm.getRecent(msg.channelId, 10);
+      const relevantFacts = this.longTerm.search(msg.content, 3);
+      const messages = [];
+      if (relevantFacts.length > 0) {
+        messages.push({
+          role: "user",
+          content: "Relevant facts from memory:\n" + relevantFacts.map((f) => `- ${f.fact}`).join("\n")
+        });
+        messages.push({ role: "assistant", content: "Noted. I'll use these facts." });
+      }
+      if (recentMemory.length > 0) {
+        for (const m of recentMemory) {
+          messages.push({
+            role: m.role === "user" ? "user" : "assistant",
+            content: m.content
+          });
+        }
+      }
+      messages.push({ role: "user", content: msg.content });
+      this.lifecycle.transition("responding");
+      const channel = this.channels.getChannelForMessage(msg);
+      if (channel) {
+        await channel.typing(msg.channelId).catch(() => {
+        });
+      }
+      this.capabilities.setChannelContext(msg.channelId, msg.channelType);
+      const fallbackIterator = this.providers.getFallbackIterator();
+      let result = null;
+      let usedProvider = null;
+      let lastError = null;
+      let streamedText = "";
+      const canStream = msg.channelType === "cli";
+      for (const provider of fallbackIterator) {
+        try {
+          logger.info({ provider: provider.name, model: provider.getModel(), steps: MAX_STEPS, stream: canStream }, "Generating agentic response");
+          if (canStream && channel) {
+            const streamResult = streamText3({
+              model: provider.getModelInstance(),
+              system: systemPrompt,
+              messages,
+              tools: this.capabilities.getTools(),
+              maxSteps: MAX_STEPS,
+              onStepFinish: async ({ toolCalls }) => {
+                if (toolCalls && toolCalls.length > 0) {
+                  const names = toolCalls.map((tc) => tc.toolName).join(", ");
+                  logger.info({ tools: names }, "Tool call step");
+                  await channel.send(`  [Using: ${names}]`, msg.channelId).catch(() => {
+                  });
+                }
+              }
+            });
+            const fullText = await channel.stream(streamResult.textStream, msg.channelId);
+            const [usage] = await Promise.all([
+              streamResult.usage
+            ]);
+            result = { text: fullText, usage };
+            streamedText = fullText;
+          } else {
+            result = await generateText3({
+              model: provider.getModelInstance(),
+              system: systemPrompt,
+              messages,
+              tools: this.capabilities.getTools(),
+              maxSteps: MAX_STEPS,
+              onStepFinish: async ({ toolCalls, text }) => {
+                if (toolCalls && toolCalls.length > 0) {
+                  const names = toolCalls.map((tc) => tc.toolName).join(", ");
+                  logger.info({ tools: names }, "Tool call step");
+                  if (channel && msg.channelType !== "internal") {
+                    await channel.send(`  [Using: ${names}]`, msg.channelId).catch(() => {
+                    });
+                  }
+                }
+              }
+            });
+          }
+          usedProvider = { name: provider.name, model: provider.getModel() };
+          this.providers.markSuccess(provider.name);
+          break;
+        } catch (err) {
+          lastError = err;
+          logger.warn({ provider: provider.name, err: err.message }, "Provider failed, trying fallback");
+          if (channel && msg.channelType !== "internal") {
+            await channel.send(`  [Provider ${provider.name} failed, trying fallback...]`, msg.channelId).catch(() => {
+            });
+          }
+        }
+      }
+      if (!result) {
+        const errMsg = `All LLM providers failed. Last error: ${lastError?.message || "unknown"}`;
+        logger.error({ err: lastError }, errMsg);
+        if (channel && msg.channelType !== "internal") {
+          await channel.send(errMsg, msg.channelId);
+        }
+        this.lifecycle.transition("idle");
+        return;
+      }
+      const finalText = streamedText || result.text;
+      this.tokenBudget.recordUsage({
+        provider: usedProvider.name,
+        model: usedProvider.model,
+        inputTokens: result.usage?.promptTokens ?? 0,
+        outputTokens: result.usage?.completionTokens ?? 0,
+        totalTokens: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0),
+        channelType: msg.channelType
+      });
+      this.shortTerm.add(msg.channelId, {
+        id: msg.id,
+        timestamp: msg.timestamp,
+        role: "user",
+        content: msg.content
+      });
+      this.shortTerm.add(msg.channelId, {
+        id: Date.now().toString(36),
+        timestamp: Date.now(),
+        role: "assistant",
+        content: finalText,
+        tokenCount: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0)
+      });
+      this.episodic.record({
+        type: "message",
+        summary: `User: ${msg.content.slice(0, 100)} | Agent: ${finalText.slice(0, 100)}`,
+        channelType: msg.channelType
+      });
+      if (msg.channelType !== "internal") {
+        this.extractFacts(msg.content, finalText).catch((err) => {
+          logger.warn({ err }, "Fact extraction failed");
+        });
+      }
+      if (channel && msg.channelType !== "internal") {
+        const elapsed = Date.now() - startTime;
+        if (streamedText) {
+          logger.info({ channelType: msg.channelType, elapsed }, "Streamed response completed");
+        } else {
+          logger.info({ channelType: msg.channelType, targetId: msg.channelId }, "Sending response");
+          await channel.send(finalText, msg.channelId, elapsed);
+        }
+      } else {
+        logger.debug("Internal prompt processed, no channel response needed");
+      }
+      this.lifecycle.transition("idle");
+    } catch (err) {
+      logger.error({ err }, "Error handling message");
+      this.lifecycle.transition("idle");
+    } finally {
+      if (isInternal || isScheduled) {
+        this.capabilities.permissions.setAutoApproveAll(false);
+      }
+      this.capabilities.permissions.clearElevation();
+    }
+  }
+  buildSystemPrompt() {
+    let prompt = this.identity.getSystemPrompt(this.config.identity);
+    const skillContext = this.capabilities.getSkillContext();
+    if (skillContext) {
+      prompt += "\n\n" + skillContext;
+    }
+    const budgetStatus = this.tokenBudget.getStatusText();
+    prompt += "\n\n" + budgetStatus;
+    if (this.tokenBudget.getUsagePercentage() > 70) {
+      prompt += "\nBe concise to conserve tokens.";
+    }
+    return prompt;
+  }
+  async processInternalPrompt(prompt, channelId, channelType) {
+    const syntheticMsg = {
+      id: `internal-${Date.now().toString(36)}`,
+      channelId: channelId || "internal",
+      channelType: channelType || "internal",
+      senderId: "system",
+      content: prompt,
+      timestamp: Date.now()
+    };
+    this.enqueueMessage(syntheticMsg);
+  }
+  async handleScheduledTask(manifest) {
+    logger.info({ task: manifest.id, channel: manifest.sourceChannelType }, "Processing scheduled task");
+    try {
+      let prompt = manifest.prompt || "";
+      if (manifest.skillName) {
+        const skillHint = `Invoke the skill "${manifest.skillName}" using the use_skill tool and follow its instructions.`;
+        prompt = prompt ? `${prompt} ${skillHint}` : `Scheduled task triggered. ${skillHint}`;
+      }
+      if (!prompt) {
+        prompt = `Execute scheduled task: ${manifest.description}`;
+      }
+      await this.processInternalPrompt(prompt, manifest.sourceChannelId, manifest.sourceChannelType);
+    } catch (err) {
+      logger.error({ err, task: manifest.id }, "Scheduled task execution failed");
+    }
+  }
+  async heartbeat() {
+    logger.debug("Heartbeat tick");
+    const pruned = this.episodic.prune(7);
+    if (pruned > 0) {
+      logger.info({ pruned }, "Episodic memory pruned");
+    }
+    const notifications = [];
+    const usagePct = this.tokenBudget.getUsagePercentage();
+    if (usagePct >= 80) {
+      notifications.push(`Token budget at ${Math.round(usagePct)}% \u2014 ${this.tokenBudget.getRemaining().toLocaleString()} tokens remaining today.`);
+    }
+    const pendingSchedules = this.scheduler.getManifests();
+    const now = Date.now();
+    for (const task of pendingSchedules) {
+      if (task.delaySeconds && task.executeAt) {
+        const executeAt = new Date(task.executeAt).getTime();
+        const diffMin = Math.round((executeAt - now) / 6e4);
+        if (diffMin > 0 && diffMin <= 5) {
+          notifications.push(`Task "${task.description}" fires in ${diffMin} minute${diffMin !== 1 ? "s" : ""}.`);
+        }
+      }
+    }
+    if (notifications.length > 0) {
+      const channel = this.channels.getNotificationChannel();
+      if (channel) {
+        const msg = notifications.join("\n");
+        try {
+          await channel.send(msg, "notification");
+        } catch (err) {
+          logger.warn({ err }, "Failed to send heartbeat notification");
+        }
+      }
+    }
+  }
+  async extractFacts(userMessage, agentResponse) {
+    const trivial = /^(hi|hello|hey|thanks|thank you|ok|okay|yes|no|bye|goodbye|good morning|good evening)\b/i;
+    if (trivial.test(userMessage.trim())) return;
+    if (!this.tokenBudget.canAfford(500)) return;
+    try {
+      const provider = this.providers.getDefault();
+      const result = await generateText3({
+        model: provider.getModelInstance(),
+        system: 'You are a fact extractor. Read the conversation below and extract 1-3 important facts worth remembering long-term. Output each fact on a separate line, prefixed with "- ". Only extract facts that are specific, factual, and not obvious. If nothing is worth remembering, output nothing.',
+        messages: [
+          { role: "user", content: `User: ${userMessage}
+Assistant: ${agentResponse}` }
+        ],
+        maxTokens: 200
+      });
+      const text = result.text.trim();
+      if (!text) return;
+      const facts = text.split("\n").map((l) => l.replace(/^-\s*/, "").trim()).filter((f) => f.length > 10 && f.length < 200);
+      const existing = this.longTerm.getAll();
+      for (const fact of facts.slice(0, 3)) {
+        const isDupe = existing.some(
+          (e) => e.fact.toLowerCase().includes(fact.toLowerCase().slice(0, 30))
+        );
+        if (!isDupe) {
+          this.longTerm.add({
+            topic: "extracted",
+            fact,
+            source: "conversation"
+          });
+          logger.info({ fact: fact.slice(0, 60) }, "Fact extracted to long-term memory");
+        }
+      }
+      this.tokenBudget.recordUsage({
+        provider: provider.name,
+        model: provider.getModel(),
+        inputTokens: result.usage?.promptTokens ?? 0,
+        outputTokens: result.usage?.completionTokens ?? 0,
+        totalTokens: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0),
+        channelType: "internal"
+      });
+    } catch (err) {
+      logger.warn({ err }, "Fact extraction error");
+    }
+  }
+  async shutdown() {
+    await this.sleep();
+    logger.info("Mercury has shut down");
+  }
+  async handleBudgetOverrideCLI(channel, msg) {
+    const status = this.tokenBudget.getStatusText();
+    await channel.send(
+      `Token budget exceeded! ${status}
+
+Choose an option:
+  1 \u2014 Override (allow this one request)
+  2 \u2014 Reset usage to zero
+  3 \u2014 Set a new daily budget (current: ${this.tokenBudget.getBudget().toLocaleString()})
+  4 \u2014 Cancel
+
+Or use /budget override, /budget reset, /budget set <number> anytime.`,
+      msg.channelId
+    );
+  }
+  async handleBudgetCommand(subcommand, channelType, channelId) {
+    const channel = this.channels.get(channelType);
+    if (!channel) return;
+    const parts = subcommand.trim().split(/\s+/);
+    const action = parts[0]?.toLowerCase();
+    if (action === "override" || action === "1") {
+      this.tokenBudget.forceAllowNext();
+      await channel.send("Budget override applied \u2014 your next request will proceed.", channelId);
+    } else if (action === "reset" || action === "2") {
+      this.tokenBudget.resetUsage();
+      await channel.send(`Usage reset to zero. ${this.tokenBudget.getStatusText()}`, channelId);
+    } else if (action === "set" || action === "3") {
+      const newBudget = parseInt(parts[1], 10);
+      if (isNaN(newBudget) || newBudget <= 0) {
+        await channel.send("Please specify the new budget. Usage: `/budget set 100000` or type e.g. `3 100000`", channelId);
+        return;
+      }
+      this.tokenBudget.setBudget(newBudget);
+      await channel.send(`Daily budget updated to ${newBudget.toLocaleString()} tokens. ${this.tokenBudget.getStatusText()}`, channelId);
+    } else if (action === "cancel" || action === "4") {
+      await channel.send(`Cancelled. ${this.tokenBudget.getStatusText()}`, channelId);
+    } else if (!action || action === "status") {
+      await channel.send(this.tokenBudget.getStatusText(), channelId);
+    } else {
+      await channel.send(`Unknown budget command "${action}". Available: /budget, /budget override, /budget reset, /budget set <number>, /budget status`, channelId);
+    }
+  }
+};
+
+// src/core/scheduler.ts
+import cron from "node-cron";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { join as join4 } from "path";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+var SCHEDULES_FILE = "schedules.yaml";
+function getSchedulesPath() {
+  return join4(getMercuryHome(), SCHEDULES_FILE);
+}
+function loadSchedules() {
+  const path3 = getSchedulesPath();
+  if (!existsSync4(path3)) return [];
+  try {
+    const raw = readFileSync4(path3, "utf-8");
+    const data = parseYaml2(raw);
+    return data.tasks || [];
+  } catch (err) {
+    logger.warn({ err }, "Failed to load schedules.yaml");
+    return [];
+  }
+}
+function saveSchedules(tasks) {
+  const path3 = getSchedulesPath();
+  const dir = getMercuryHome();
+  if (!existsSync4(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  writeFileSync4(path3, stringifyYaml2({ tasks }), "utf-8");
+}
+var Scheduler = class {
+  constructor(config, onScheduledTask) {
+    this.onScheduledTask = onScheduledTask;
+    this.heartbeatIntervalMinutes = config.heartbeat.intervalMinutes;
+  }
+  onScheduledTask;
+  tasks = /* @__PURE__ */ new Map();
+  delayedTasks = /* @__PURE__ */ new Map();
+  taskManifests = /* @__PURE__ */ new Map();
+  heartbeatIntervalMinutes;
+  heartbeatHandler;
+  heartbeatTimer = null;
+  setOnScheduledTask(handler) {
+    this.onScheduledTask = handler;
+  }
+  onHeartbeat(handler) {
+    this.heartbeatHandler = handler;
+  }
+  startHeartbeat() {
+    if (this.heartbeatTimer) return;
+    const ms = this.heartbeatIntervalMinutes * 60 * 1e3;
+    logger.info({ intervalMin: this.heartbeatIntervalMinutes }, "Heartbeat started");
+    this.heartbeatTimer = setInterval(async () => {
+      try {
+        await this.heartbeatHandler?.();
+      } catch (err) {
+        logger.error({ err }, "Heartbeat error");
+      }
+    }, ms);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+      logger.info("Heartbeat stopped");
+    }
+  }
+  addTask(task) {
+    if (this.tasks.has(task.id)) {
+      this.removeTask(task.id);
+    }
+    const scheduled = cron.schedule(task.cron, async () => {
+      try {
+        await task.handler();
+      } catch (err) {
+        logger.error({ task: task.id, err }, "Scheduled task error");
+      }
+    });
+    this.tasks.set(task.id, scheduled);
+    logger.info({ id: task.id, cron: task.cron, desc: task.description }, "Task scheduled");
+  }
+  addPersistedTask(manifest) {
+    this.taskManifests.set(manifest.id, manifest);
+    this.addTask({
+      id: manifest.id,
+      cron: manifest.cron,
+      description: manifest.description,
+      handler: async () => {
+        logger.info({ task: manifest.id }, "Scheduled task firing");
+        if (this.onScheduledTask) {
+          await this.onScheduledTask(manifest);
+        }
+      }
+    });
+  }
+  addDelayedTask(manifest) {
+    this.taskManifests.set(manifest.id, manifest);
+    const delayMs = (manifest.delaySeconds || 60) * 1e3;
+    const timer = setTimeout(async () => {
+      try {
+        logger.info({ task: manifest.id }, "Delayed task firing");
+        if (this.onScheduledTask) {
+          await this.onScheduledTask(manifest);
+        }
+      } catch (err) {
+        logger.error({ task: manifest.id, err }, "Delayed task error");
+      } finally {
+        this.delayedTasks.delete(manifest.id);
+        this.taskManifests.delete(manifest.id);
+        this.persistSchedules();
+      }
+    }, delayMs);
+    this.delayedTasks.set(manifest.id, timer);
+    logger.info({ id: manifest.id, delaySeconds: manifest.delaySeconds }, "Delayed task scheduled");
+  }
+  removeTask(id) {
+    const task = this.tasks.get(id);
+    if (task) {
+      task.stop();
+      this.tasks.delete(id);
+    }
+    const timer = this.delayedTasks.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      this.delayedTasks.delete(id);
+    }
+    this.taskManifests.delete(id);
+  }
+  getManifests() {
+    return [...this.taskManifests.values()];
+  }
+  restorePersistedTasks() {
+    const persisted = loadSchedules();
+    for (const manifest of persisted) {
+      if (manifest.delaySeconds) {
+        const executeAt = manifest.executeAt ? new Date(manifest.executeAt) : null;
+        const now = Date.now();
+        if (executeAt && executeAt.getTime() > now) {
+          const remainingMs = executeAt.getTime() - now;
+          manifest.delaySeconds = Math.ceil(remainingMs / 1e3);
+          this.addDelayedTask(manifest);
+        } else {
+          logger.info({ id: manifest.id }, "Delayed task already expired, skipping");
+        }
+      } else if (manifest.cron && cron.validate(manifest.cron)) {
+        this.addPersistedTask(manifest);
+      } else {
+        logger.warn({ id: manifest.id, cron: manifest.cron }, "Skipping invalid task");
+      }
+    }
+    if (persisted.length > 0) {
+      logger.info({ count: persisted.length }, "Restored persisted scheduled tasks");
+    }
+  }
+  persistSchedules() {
+    saveSchedules(this.getManifests());
+  }
+  stopAll() {
+    this.stopHeartbeat();
+    for (const [, task] of this.tasks) {
+      task.stop();
+    }
+    for (const [, timer] of this.delayedTasks) {
+      clearTimeout(timer);
+    }
+    this.tasks.clear();
+    this.delayedTasks.clear();
+    this.taskManifests.clear();
+  }
+};
+
+// src/channels/cli.ts
+import readline from "readline";
+import fs from "fs";
+import path from "path";
+import chalk2 from "chalk";
+
+// src/channels/base.ts
+var BaseChannel = class {
+  messageHandler;
+  ready = false;
+  isReady() {
+    return this.ready;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  emit(message) {
+    this.messageHandler?.(message);
+  }
+};
+
+// src/utils/markdown.ts
+import { Marked } from "marked";
+import chalk from "chalk";
+var lexer = new Marked();
+function renderMarkdown(text) {
+  try {
+    const tokens = lexer.lexer(text);
+    const result = renderTokens(tokens);
+    return result.replace(/\n{3,}/g, "\n\n").trimEnd();
+  } catch {
+    return text;
+  }
+}
+function renderTokens(tokens) {
+  return tokens.map((t) => renderToken(t)).join("");
+}
+function renderToken(t) {
+  if (!t || typeof t !== "object") return String(t ?? "");
+  switch (t.type) {
+    case "heading":
+      return renderHeading(t);
+    case "paragraph":
+      return renderInline(t.tokens) + "\n\n";
+    case "strong":
+      return chalk.bold(renderInline(t.tokens));
+    case "em":
+      return chalk.italic(renderInline(t.tokens));
+    case "del":
+      return chalk.dim.strikethrough(renderInline(t.tokens));
+    case "codespan":
+      return chalk.yellow(t.text);
+    case "code":
+      return renderCodeBlock(t);
+    case "list":
+      return renderList(t);
+    case "blockquote":
+      return renderBlockquote(t);
+    case "hr":
+      return chalk.dim("\u2500".repeat(50)) + "\n\n";
+    case "link":
+      return `${chalk.blue.underline(renderInline(t.tokens))} ${chalk.dim(`(${t.href})`)}`;
+    case "image":
+      return chalk.blue(`\u{1F5BC} ${t.title || t.href}`);
+    case "table":
+      return renderTable(t);
+    case "text":
+      if (t.tokens) return renderInline(t.tokens);
+      return t.text || "";
+    case "html":
+      return t.text || "";
+    case "space":
+      return "";
+    default:
+      return t.text || "";
+  }
+}
+function renderHeading(t) {
+  const text = renderInline(t.tokens);
+  if (t.depth === 1) return `
+${chalk.bold.cyan(text)}
+
+`;
+  if (t.depth === 2) return `
+${chalk.bold.cyan(`  \u25A0 ${text}`)}
+
+`;
+  return `
+${chalk.bold(`    \u25A0 ${text}`)}
+
+`;
+}
+function renderInline(tokens) {
+  if (!tokens) return "";
+  return tokens.map((t) => {
+    if (typeof t === "string") return t;
+    if (t.type === "strong") return chalk.bold(renderInline(t.tokens));
+    if (t.type === "em") return chalk.italic(renderInline(t.tokens));
+    if (t.type === "del") return chalk.dim.strikethrough(renderInline(t.tokens));
+    if (t.type === "codespan") return chalk.yellow(t.text);
+    if (t.type === "link") return `${chalk.blue.underline(renderInline(t.tokens))} ${chalk.dim(`(${t.href})`)}`;
+    if (t.type === "image") return chalk.blue(`\u{1F5BC} ${t.title || t.href}`);
+    if (t.type === "text") {
+      return t.tokens ? renderInline(t.tokens) : t.text || "";
+    }
+    if (t.type === "html") return t.text || "";
+    return t.text || "";
+  }).join("");
+}
+function renderCodeBlock(t) {
+  const lines = t.text.split("\n").map((l) => `${chalk.dim("  ")}${chalk.yellow(l)}`).join("\n");
+  const langStr = t.lang ? chalk.dim(` [${t.lang}]`) : "";
+  return `
+${langStr}
+${lines}
+
+`;
+}
+function renderList(t) {
+  const lines = [];
+  const items = t.items || [];
+  items.forEach((item, i) => {
+    const bullet = t.ordered ? `${i + 1}.` : "\u2022";
+    const firstLine = renderInline(item.tokens?.[0]?.tokens || [{ text: item.text }]);
+    lines.push(`  ${chalk.dim(bullet)} ${firstLine}`);
+    const restTokens = (item.tokens || []).slice(1);
+    for (const sub of restTokens) {
+      if (sub.type === "list") {
+        const subLines = renderList(sub).split("\n").filter(Boolean).map((l) => `    ${l}`).join("\n");
+        lines.push(subLines);
+      } else if (sub.type === "text") {
+        lines.push(`    ${chalk.dim("\u2022")} ${renderInline(sub.tokens)}`);
+      }
+    }
+  });
+  return lines.join("\n") + "\n\n";
+}
+function renderBlockquote(t) {
+  const content = renderTokens(t.tokens || []);
+  const lines = content.split("\n").filter((l) => l.trim()).map((l) => `${chalk.dim("\u2502 ")}${chalk.gray(l)}`).join("\n");
+  return `
+${lines}
+
+`;
+}
+function renderTable(t) {
+  const headers = (t.header || []).map((h) => chalk.bold(renderInline(h.tokens)));
+  const colWidths = (t.header || []).map((h, i) => {
+    const hLen = (h.text || "").length;
+    const rowLens = (t.rows || []).map((row) => {
+      const cell = row[i];
+      return cell?.text?.length ?? 0;
+    });
+    return Math.max(hLen, ...rowLens) + 2;
+  });
+  const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join(chalk.dim(" \u2502 "));
+  const separator = colWidths.map((w) => "\u2500".repeat(w)).join(chalk.dim("\u2500\u253C\u2500"));
+  const dataLines = (t.rows || []).map(
+    (row) => row.map((cell, i) => {
+      const text = renderInline(cell.tokens) || cell.text || "";
+      return text.padEnd(colWidths[i]);
+    }).join(chalk.dim(" \u2502 "))
+  );
+  return `
+${headerLine}
+${chalk.dim(separator)}
+${dataLines.join("\n")}
+
+`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function mdToTelegram(text) {
+  let out = text;
+  const codeBlocks = [];
+  out = out.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, lang, code) => {
+    const placeholder = `__CODEBLOCK_${codeBlocks.length}__`;
+    codeBlocks.push(`<pre><code class="${lang}">${escapeHtml(code)}</code></pre>`);
+    return placeholder;
+  });
+  const inlineCodes = [];
+  out = out.replace(/`([^`]+)`/g, (_match, code) => {
+    const placeholder = `__INLINECODE_${inlineCodes.length}__`;
+    inlineCodes.push(`<code>${escapeHtml(code)}</code>`);
+    return placeholder;
+  });
+  const links = [];
+  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, label, href) => {
+    const placeholder = `__LINK_${links.length}__`;
+    links.push(`<a href="${escapeHtml(href)}">${escapeHtml(label)}</a>`);
+    return placeholder;
+  });
+  out = escapeHtml(out);
+  out = out.replace(/^### (.+)$/gm, "<b><i>$1</i></b>");
+  out = out.replace(/^## (.+)$/gm, "<b>$1</b>");
+  out = out.replace(/^# (.+)$/gm, "<b>$1</b>");
+  out = out.replace(/\*\*([^*]+)\*\*/g, "<b>$1</b>");
+  out = out.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "<i>$1</i>");
+  out = out.replace(/~~([^~]+)~~/g, "<s>$1</s>");
+  for (let i = 0; i < inlineCodes.length; i++) {
+    out = out.replace(`__INLINECODE_${i}__`, inlineCodes[i]);
+  }
+  for (let i = 0; i < codeBlocks.length; i++) {
+    out = out.replace(`__CODEBLOCK_${i}__`, codeBlocks[i]);
+  }
+  for (let i = 0; i < links.length; i++) {
+    out = out.replace(`__LINK_${i}__`, links[i]);
+  }
+  if (out.length > 4096) {
+    out = out.slice(0, 4090) + "...";
+  }
+  return out;
+}
+
+// src/channels/cli.ts
+var CLIChannel = class extends BaseChannel {
+  type = "cli";
+  rl = null;
+  agentName;
+  constructor(agentName = "Mercury") {
+    super();
+    this.agentName = agentName;
+  }
+  setAgentName(name) {
+    this.agentName = name;
+  }
+  async start() {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: "  You: "
+    });
+    this.rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        this.showPrompt();
+        return;
+      }
+      const msg = {
+        id: Date.now().toString(36),
+        channelId: "cli",
+        channelType: "cli",
+        senderId: "owner",
+        content: trimmed,
+        timestamp: Date.now()
+      };
+      this.emit(msg);
+    });
+    this.ready = true;
+    this.showPrompt();
+    logger.info("CLI channel started");
+  }
+  async stop() {
+    this.rl?.close();
+    this.rl = null;
+    this.ready = false;
+  }
+  async send(content, _targetId, elapsedMs) {
+    const timeStr = elapsedMs != null ? chalk2.dim(` (${(elapsedMs / 1e3).toFixed(1)}s)`) : "";
+    const rendered = renderMarkdown(content);
+    console.log("");
+    console.log(chalk2.cyan(`  ${this.agentName}:`) + timeStr);
+    const indented = rendered.split("\n").map((line) => `  ${line}`).join("\n");
+    console.log(indented);
+    console.log("");
+    this.showPrompt();
+  }
+  async sendFile(filePath, _targetId) {
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) {
+      console.log(chalk2.red(`  File not found: ${filePath}`));
+      return;
+    }
+    const stat = fs.statSync(resolved);
+    const sizeStr = stat.size > 1024 * 1024 ? `${(stat.size / (1024 * 1024)).toFixed(1)}MB` : stat.size > 1024 ? `${(stat.size / 1024).toFixed(1)}KB` : `${stat.size}B`;
+    console.log("");
+    console.log(chalk2.cyan(`  ${this.agentName}:`) + chalk2.dim(" (file)"));
+    console.log(chalk2.dim(`  path: ${resolved}`));
+    console.log(chalk2.dim(`  size: ${sizeStr}`));
+    console.log("");
+    this.showPrompt();
+  }
+  async stream(content, _targetId) {
+    console.log("");
+    process.stdout.write(chalk2.cyan(`  ${this.agentName}: `));
+    let full = "";
+    for await (const chunk of content) {
+      process.stdout.write(chunk);
+      full += chunk;
+    }
+    console.log("\n");
+    this.showPrompt();
+    return full;
+  }
+  async typing(_targetId) {
+    process.stdout.write(chalk2.dim(`  ${this.agentName} is thinking...\r`));
+  }
+  showPrompt() {
+    if (this.rl) {
+      this.rl.setPrompt("  You: ");
+      this.rl.prompt();
+    }
+  }
+  async prompt(question) {
+    return new Promise((resolve9) => {
+      this.rl?.question(question, (answer) => resolve9(answer.trim()));
+    });
+  }
+  async askPermission(prompt) {
+    return new Promise((resolve9) => {
+      console.log("");
+      console.log(chalk2.yellow(`  \u26A0 ${prompt}`));
+      this.rl?.question(chalk2.yellow("  > "), (answer) => {
+        resolve9(answer.trim());
+      });
+    });
+  }
+};
+
+// src/channels/telegram.ts
+import fs2 from "fs";
+import path2 from "path";
+import { Bot, InputFile } from "grammy";
+import { autoRetry } from "@grammyjs/auto-retry";
+var MAX_MESSAGE_LENGTH = 4096;
+var TelegramChannel = class extends BaseChannel {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  config;
+  type = "telegram";
+  bot = null;
+  ownerChatId = null;
+  typingInterval = null;
+  async start() {
+    const token = this.config.channels.telegram.botToken;
+    if (!token) {
+      logger.warn("Telegram bot token not set \u2014 skipping");
+      return;
+    }
+    const bot = new Bot(token);
+    bot.api.config.use(autoRetry());
+    bot.on("message:text", async (ctx) => {
+      const chatId = ctx.chat.id;
+      if (!this.isAllowedChat(chatId)) return;
+      this.ownerChatId = chatId;
+      logger.info({ chatId, text: ctx.message.text?.slice(0, 50) }, "Telegram message received");
+      const msg = {
+        id: ctx.message.message_id.toString(),
+        channelId: `telegram:${chatId}`,
+        channelType: "telegram",
+        senderId: ctx.from?.id.toString() ?? "unknown",
+        senderName: ctx.from?.first_name,
+        content: ctx.message.text,
+        timestamp: ctx.message.date * 1e3,
+        metadata: { chatId, messageId: ctx.message.message_id }
+      };
+      this.emit(msg);
+    });
+    bot.catch((err) => {
+      logger.error({ err: err.message }, "Telegram bot error");
+    });
+    this.bot = bot;
+    await bot.start({
+      onStart: (info) => {
+        logger.info({ bot: info.username }, "Telegram bot started \u2014 long polling active");
+        this.ready = true;
+      }
+    });
+  }
+  async stop() {
+    this.bot?.stop();
+    this.ready = false;
+    this.stopTypingLoop();
+  }
+  async send(content, targetId, elapsedMs) {
+    const chatId = this.parseChatId(targetId);
+    if (!chatId || !this.bot) {
+      logger.warn({ targetId, chatId }, "Telegram send: no valid chat ID");
+      return;
+    }
+    const timeSuffix = elapsedMs != null ? `
+\u23F1 ${(elapsedMs / 1e3).toFixed(1)}s` : "";
+    const fullContent = content + timeSuffix;
+    const html = mdToTelegram(fullContent);
+    const chunks = this.splitMessage(html, MAX_MESSAGE_LENGTH);
+    for (const chunk of chunks) {
+      try {
+        await this.bot.api.sendMessage(chatId, chunk, { parse_mode: "HTML" });
+      } catch (err) {
+        logger.warn({ err: err.message }, "HTML parse failed, sending as plain text");
+        try {
+          await this.bot.api.sendMessage(chatId, this.stripHtml(chunk));
+        } catch (err2) {
+          logger.error({ err: err2.message }, "Telegram send failed");
+        }
+      }
+    }
+  }
+  async sendFile(filePath, targetId) {
+    const chatId = this.parseChatId(targetId);
+    if (!chatId || !this.bot) {
+      logger.warn({ targetId, chatId }, "Telegram sendFile: no valid chat ID");
+      return;
+    }
+    const resolved = path2.resolve(filePath);
+    if (!fs2.existsSync(resolved)) {
+      await this.bot.api.sendMessage(chatId, `File not found: ${filePath}`);
+      return;
+    }
+    const inputFile = new InputFile(resolved);
+    const filename = path2.basename(resolved);
+    const ext = path2.extname(resolved).toLowerCase();
+    try {
+      if (this.isImageFile(ext)) {
+        await this.bot.api.sendPhoto(chatId, inputFile, { caption: filename });
+      } else if (this.isAudioFile(ext)) {
+        await this.bot.api.sendAudio(chatId, inputFile, { title: filename });
+      } else if (this.isVideoFile(ext)) {
+        await this.bot.api.sendVideo(chatId, inputFile, { caption: filename });
+      } else {
+        await this.bot.api.sendDocument(chatId, inputFile, { caption: filename });
+      }
+      logger.info({ file: resolved, chatId }, "File sent via Telegram");
+    } catch (err) {
+      logger.error({ err: err.message, file: resolved }, "Telegram sendFile failed");
+      await this.bot.api.sendMessage(chatId, `Failed to send file: ${err.message}`).catch(() => {
+      });
+    }
+  }
+  async stream(content, targetId) {
+    const chatId = this.parseChatId(targetId);
+    if (!chatId || !this.bot) return "";
+    let full = "";
+    for await (const chunk of content) {
+      full += chunk;
+    }
+    const html = mdToTelegram(full);
+    try {
+      await this.bot.api.sendMessage(chatId, html, { parse_mode: "HTML" });
+    } catch (err) {
+      await this.bot.api.sendMessage(chatId, this.stripHtml(html));
+    }
+    return full;
+  }
+  async typing(targetId) {
+    const chatId = this.parseChatId(targetId);
+    if (!chatId || !this.bot) return;
+    await this.bot.api.sendChatAction(chatId, "typing");
+  }
+  startTypingLoop(chatId) {
+    this.stopTypingLoop();
+    this.bot?.api.sendChatAction(chatId, "typing").catch(() => {
+    });
+    this.typingInterval = setInterval(() => {
+      this.bot?.api.sendChatAction(chatId, "typing").catch(() => {
+      });
+    }, 4e3);
+  }
+  stopTypingLoop() {
+    if (this.typingInterval) {
+      clearInterval(this.typingInterval);
+      this.typingInterval = null;
+    }
+  }
+  async sendStreamToChat(chatId, textStream) {
+    if (!this.bot) return;
+    this.startTypingLoop(chatId);
+    try {
+      let full = "";
+      for await (const chunk of textStream) {
+        full += chunk;
+      }
+      const html = mdToTelegram(full);
+      try {
+        await this.bot.api.sendMessage(chatId, html, { parse_mode: "HTML" });
+      } catch {
+        await this.bot.api.sendMessage(chatId, this.stripHtml(html));
+      }
+    } finally {
+      this.stopTypingLoop();
+    }
+  }
+  splitMessage(text, maxLen) {
+    if (text.length <= maxLen) return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+      let splitAt = maxLen;
+      if (remaining.length > maxLen) {
+        const lastNewline = remaining.lastIndexOf("\n", maxLen);
+        if (lastNewline > maxLen * 0.5) {
+          splitAt = lastNewline + 1;
+        }
+      }
+      chunks.push(remaining.slice(0, splitAt));
+      remaining = remaining.slice(splitAt);
+    }
+    return chunks;
+  }
+  stripHtml(html) {
+    return html.replace(/<\/?(b|i|s|u|code|pre|a|blockquote|strong|em)[^>]*>/gi, "").replace(/<pre><code[^>]*>/gi, "").replace(/<\/code><\/pre>/gi, "").replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+  }
+  isImageFile(ext) {
+    return [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg"].includes(ext);
+  }
+  isAudioFile(ext) {
+    return [".mp3", ".ogg", ".wav", ".flac", ".m4a"].includes(ext);
+  }
+  isVideoFile(ext) {
+    return [".mp4", ".mov", ".avi", ".mkv", ".webm"].includes(ext);
+  }
+  parseChatId(targetId) {
+    if (!targetId) return this.ownerChatId;
+    if (targetId.startsWith("telegram:")) {
+      const raw = Number(targetId.split(":")[1]);
+      return isNaN(raw) ? this.ownerChatId : raw;
+    }
+    if (targetId === "notification") return this.ownerChatId;
+    const num = Number(targetId);
+    return isNaN(num) ? this.ownerChatId : num;
+  }
+  isAllowedChat(chatId) {
+    const allowed = this.config.channels.telegram.allowedChatIds;
+    if (!allowed || allowed.length === 0) return true;
+    return allowed.includes(chatId);
+  }
+};
+
+// src/channels/registry.ts
+var ChannelRegistry = class {
+  channels = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.register("cli", new CLIChannel(config.identity.name));
+    if (config.channels.telegram.enabled && config.channels.telegram.botToken) {
+      this.register("telegram", new TelegramChannel(config));
+    }
+  }
+  register(type, channel) {
+    channel.onMessage((msg) => this.handleIncomingMessage(msg));
+    this.channels.set(type, channel);
+    logger.info({ channel: type }, "Channel registered");
+  }
+  get(type) {
+    return this.channels.get(type);
+  }
+  getChannelForMessage(message) {
+    return this.channels.get(message.channelType);
+  }
+  async startAll() {
+    for (const [type, channel] of this.channels) {
+      try {
+        await channel.start();
+      } catch (err) {
+        logger.error({ channel: type, err }, "Failed to start channel");
+      }
+    }
+  }
+  async stopAll() {
+    for (const [, channel] of this.channels) {
+      await channel.stop();
+    }
+  }
+  getActiveChannels() {
+    return [...this.channels.entries()].filter(([, ch]) => ch.isReady()).map(([type]) => type);
+  }
+  getNotificationChannel() {
+    const telegram = this.channels.get("telegram");
+    if (telegram?.isReady()) return telegram;
+    const cli = this.channels.get("cli");
+    if (cli?.isReady()) return cli;
+    return this.channels.values().next().value;
+  }
+  incomingHandler;
+  onIncomingMessage(handler) {
+    this.incomingHandler = handler;
+  }
+  handleIncomingMessage(msg) {
+    logger.debug({ from: msg.channelType, sender: msg.senderId }, "Incoming message");
+    this.incomingHandler?.(msg);
+  }
+};
+
+// src/utils/tokens.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join5 } from "path";
+var TOKEN_FILE = "token-usage.json";
+var TokenBudget = class {
+  constructor(config) {
+    this.config = config;
+    this.dailyBudget = config.tokens.dailyBudget;
+    this.lastResetDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    this.restore();
+  }
+  config;
+  dailyUsed = 0;
+  dailyBudget;
+  lastResetDate;
+  requestLog = [];
+  forceNext = false;
+  canAfford(estimatedTokens) {
+    this.resetIfNewDay();
+    return this.dailyUsed + estimatedTokens <= this.dailyBudget;
+  }
+  isOverBudget() {
+    this.resetIfNewDay();
+    if (this.forceNext) {
+      this.forceNext = false;
+      return false;
+    }
+    return this.dailyUsed >= this.dailyBudget;
+  }
+  forceAllowNext() {
+    this.forceNext = true;
+    logger.info("Budget override: next request will proceed regardless of budget");
+  }
+  resetUsage() {
+    this.dailyUsed = 0;
+    this.requestLog = [];
+    this.persist();
+    logger.info("Token usage reset to zero");
+  }
+  setBudget(newBudget) {
+    this.dailyBudget = newBudget;
+    this.config.tokens.dailyBudget = newBudget;
+    saveConfig(this.config);
+    this.persist();
+    logger.info({ newBudget }, "Daily token budget updated");
+  }
+  getBudget() {
+    return this.dailyBudget;
+  }
+  getDailyUsed() {
+    this.resetIfNewDay();
+    return this.dailyUsed;
+  }
+  recordUsage(entry) {
+    this.resetIfNewDay();
+    const logEntry = { ...entry, timestamp: Date.now() };
+    this.dailyUsed += entry.totalTokens;
+    this.requestLog.push(logEntry);
+    this.persist();
+  }
+  getRemaining() {
+    this.resetIfNewDay();
+    return Math.max(0, this.dailyBudget - this.dailyUsed);
+  }
+  getUsagePercentage() {
+    this.resetIfNewDay();
+    return this.dailyBudget > 0 ? this.dailyUsed / this.dailyBudget * 100 : 0;
+  }
+  getStatusText() {
+    const pct = Math.round(this.getUsagePercentage());
+    const remaining = this.getRemaining();
+    return `Token budget: ${this.dailyUsed.toLocaleString()} / ${this.dailyBudget.toLocaleString()} used (${pct}%), ${remaining.toLocaleString()} remaining`;
+  }
+  resetIfNewDay() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    if (today !== this.lastResetDate) {
+      this.dailyUsed = 0;
+      this.lastResetDate = today;
+      this.requestLog = [];
+      this.persist();
+      logger.info("Token budget reset for new day");
+    }
+  }
+  persist() {
+    const path3 = join5(getMercuryHome(), TOKEN_FILE);
+    try {
+      const data = {
+        dailyUsed: this.dailyUsed,
+        dailyBudget: this.dailyBudget,
+        lastResetDate: this.lastResetDate,
+        requestLog: this.requestLog.slice(-200)
+      };
+      writeFileSync5(path3, JSON.stringify(data, null, 2), "utf-8");
+    } catch (err) {
+      logger.warn({ err }, "Failed to persist token usage");
+    }
+  }
+  restore() {
+    const path3 = join5(getMercuryHome(), TOKEN_FILE);
+    if (!existsSync5(path3)) return;
+    try {
+      const raw = readFileSync5(path3, "utf-8");
+      const data = JSON.parse(raw);
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      if (data.lastResetDate === today) {
+        this.dailyUsed = data.dailyUsed ?? 0;
+        this.requestLog = data.requestLog ?? [];
+      }
+      this.lastResetDate = data.lastResetDate ?? today;
+    } catch (err) {
+      logger.warn({ err }, "Failed to restore token usage");
+    }
+  }
+};
+
+// src/capabilities/permissions.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "fs";
+import { join as join6, resolve } from "path";
+import { homedir as homedir2 } from "os";
+import { parse as parseYaml3, stringify as stringifyYaml3 } from "yaml";
+var DEFAULT_MANIFEST = {
+  capabilities: {
+    filesystem: {
+      enabled: true,
+      scopes: [
+        { path: ".", read: true, write: true }
+      ]
+    },
+    shell: {
+      enabled: true,
+      blocked: [
+        "sudo *",
+        "rm -rf /",
+        "rm -rf ~",
+        "rm -rf /*",
+        "mkfs *",
+        "dd if=*",
+        "chmod 777 /",
+        "chown * /",
+        ":(){ :|:& };:",
+        "shutdown *",
+        "reboot *",
+        "halt *",
+        "init 0",
+        "init 6",
+        "kill -9 1",
+        "> /dev/sda",
+        "mv /* /dev/null"
+      ],
+      autoApproved: [
+        "ls *",
+        "cat *",
+        "pwd",
+        "which *",
+        "node *",
+        "npm run *",
+        "npm test *",
+        "npm list *",
+        "git status *",
+        "git diff *",
+        "git log *",
+        "git branch *",
+        "echo *",
+        "head *",
+        "tail *",
+        "wc *",
+        "find *",
+        "grep *",
+        "rg *",
+        "ps *",
+        "df *",
+        "du *",
+        "uname *",
+        "curl *",
+        "wget *"
+      ],
+      needsApproval: [
+        "npm publish *",
+        "git push *",
+        "docker *",
+        "curl * | sh",
+        "curl * | bash",
+        "wget * | sh",
+        "pip install *",
+        "pip3 install *",
+        "rm -r *",
+        "rm -rf *",
+        "mv *",
+        "cp -r *",
+        "chmod *",
+        "mkdir *",
+        "rmdir *"
+      ],
+      cwdOnly: true
+    },
+    git: {
+      enabled: true,
+      autoApproveRead: true,
+      approveWrite: true
+    }
+  }
+};
+var PERMISSIONS_FILE = join6(getMercuryHome(), "permissions.yaml");
+var PermissionManager = class {
+  manifest;
+  cwd;
+  askHandler;
+  autoApproveAll = false;
+  elevatedCommands = /* @__PURE__ */ new Set();
+  pendingApprovals = /* @__PURE__ */ new Set();
+  constructor() {
+    this.cwd = process.cwd();
+    this.manifest = this.load();
+  }
+  onAsk(handler) {
+    this.askHandler = handler;
+  }
+  setAutoApproveAll(value) {
+    this.autoApproveAll = value;
+  }
+  elevateForSkill(allowedTools) {
+    if (allowedTools.includes("run_command")) {
+      this.elevatedCommands.add("run_command");
+    }
+    if (allowedTools.includes("read_file") || allowedTools.includes("list_dir")) {
+      this.elevatedCommands.add("fs_read");
+    }
+    if (allowedTools.includes("write_file") || allowedTools.includes("create_file") || allowedTools.includes("delete_file")) {
+      this.elevatedCommands.add("fs_write");
+    }
+  }
+  clearElevation() {
+    this.elevatedCommands.clear();
+  }
+  isElevated(tool24) {
+    if (this.elevatedCommands.has(tool24)) return true;
+    return false;
+  }
+  isShellElevated() {
+    return this.elevatedCommands.has("run_command");
+  }
+  addPendingApproval(baseCommand) {
+    this.pendingApprovals.add(baseCommand);
+  }
+  clearPendingApprovals() {
+    this.pendingApprovals.clear();
+  }
+  load() {
+    if (existsSync6(PERMISSIONS_FILE)) {
+      try {
+        const raw = readFileSync6(PERMISSIONS_FILE, "utf-8");
+        const parsed = parseYaml3(raw);
+        return this.mergeDefaults(parsed);
+      } catch (err) {
+        logger.warn({ err }, "Failed to parse permissions.yaml, using defaults");
+        return { ...DEFAULT_MANIFEST };
+      }
+    }
+    this.save(DEFAULT_MANIFEST);
+    return { ...DEFAULT_MANIFEST };
+  }
+  save(manifest) {
+    const m = manifest || this.manifest;
+    const dir = getMercuryHome();
+    if (!existsSync6(dir)) mkdirSync6(dir, { recursive: true });
+    writeFileSync6(PERMISSIONS_FILE, stringifyYaml3(m, { lineWidth: 0 }), "utf-8");
+    this.manifest = m;
+  }
+  getManifest() {
+    return this.manifest;
+  }
+  addApprovedCommand(baseCommand) {
+    const cmdName = baseCommand.trim().split(/\s+/)[0];
+    const pattern = `${cmdName} *`;
+    const shell = this.manifest.capabilities.shell;
+    if (!shell.autoApproved.includes(pattern) && !shell.autoApproved.includes(cmdName)) {
+      shell.autoApproved.push(pattern);
+      this.save();
+      logger.info({ pattern }, "Shell command pattern auto-approved and saved");
+    }
+  }
+  async checkFsAccess(path3, mode) {
+    if (mode === "read" && this.elevatedCommands.has("fs_read")) {
+      return { allowed: true };
+    }
+    if (mode === "write" && this.elevatedCommands.has("fs_write")) {
+      return { allowed: true };
+    }
+    const fs3 = this.manifest.capabilities.filesystem;
+    if (!fs3.enabled) {
+      return { allowed: false, reason: "Filesystem capability is disabled" };
+    }
+    const resolved = resolve(path3);
+    const scope = this.findScope(resolved);
+    if (scope) {
+      if (mode === "read" && scope.read) return { allowed: true };
+      if (mode === "write" && scope.write) return { allowed: true };
+      return { allowed: false, reason: `Permission denied: ${mode} access to ${path3} (scope has ${mode}=false)` };
+    }
+    return await this.requestScope(resolved, mode);
+  }
+  async checkShellCommand(command) {
+    if (this.autoApproveAll) {
+      logger.info({ cmd: command.trim() }, "Shell command auto-approved (auto-approve-all mode)");
+      return { allowed: true, needsApproval: false };
+    }
+    if (this.isShellElevated()) {
+      logger.info({ cmd: command.trim() }, "Shell command auto-approved (skill elevation)");
+      return { allowed: true, needsApproval: false };
+    }
+    const shell = this.manifest.capabilities.shell;
+    if (!shell.enabled) {
+      return { allowed: false, reason: "Shell capability is disabled", needsApproval: false };
+    }
+    const trimmed = command.trim();
+    const baseCmd = trimmed.split(/\s+/)[0];
+    if (this.pendingApprovals.has(baseCmd)) {
+      logger.info({ cmd: trimmed }, "Shell command auto-approved (pending approval)");
+      return { allowed: true, needsApproval: false };
+    }
+    for (const pattern of shell.blocked) {
+      if (this.matchPattern(trimmed, pattern)) {
+        return { allowed: false, reason: `Blocked command: matches "${pattern}"`, needsApproval: false };
+      }
+    }
+    if (shell.cwdOnly) {
+      const hasPathTraversal = this.hasPathBeyondCwd(trimmed);
+      if (hasPathTraversal) {
+        const scopeCheck = await this.checkFsAccess(hasPathTraversal, "write");
+        if (!scopeCheck.allowed) {
+          return { allowed: false, reason: scopeCheck.reason, needsApproval: true };
+        }
+      }
+    }
+    for (const pattern of shell.autoApproved) {
+      if (this.matchPattern(trimmed, pattern)) {
+        logger.info({ cmd: trimmed }, "Shell command auto-approved");
+        return { allowed: true, needsApproval: false };
+      }
+    }
+    for (const pattern of shell.needsApproval) {
+      if (this.matchPattern(trimmed, pattern)) {
+        return { allowed: false, reason: `Command requires approval: matches "${pattern}"`, needsApproval: true };
+      }
+    }
+    return { allowed: false, reason: "Command not in auto-approve list \u2014 requires approval", needsApproval: true };
+  }
+  isGitReadAllowed() {
+    return this.manifest.capabilities.git.enabled && this.manifest.capabilities.git.autoApproveRead;
+  }
+  isGitWriteNeedsApproval() {
+    return this.manifest.capabilities.git.enabled && this.manifest.capabilities.git.approveWrite;
+  }
+  addScope(path3, read, write) {
+    const resolved = resolve(path3);
+    const existing = this.findScope(resolved);
+    if (existing) {
+      existing.read = existing.read || read;
+      existing.write = existing.write || write;
+    } else {
+      this.manifest.capabilities.filesystem.scopes.push({
+        path: resolved,
+        read,
+        write
+      });
+    }
+    this.save();
+    logger.info({ path: resolved, read, write }, "Permission scope added");
+  }
+  findScope(resolvedPath) {
+    const scopes = this.manifest.capabilities.filesystem.scopes;
+    for (const scope of scopes) {
+      const scopeResolved = resolve(scope.path.replace(/^~/, homedir2()));
+      if (resolvedPath === scopeResolved || resolvedPath.startsWith(scopeResolved + "/")) {
+        return scope;
+      }
+    }
+    return void 0;
+  }
+  async requestScope(path3, mode) {
+    if (!this.askHandler) {
+      return { allowed: false, reason: `No permission to ${mode} ${path3}. Add scope to ~/.mercury/permissions.yaml` };
+    }
+    const response = await this.askHandler(
+      `Mercury needs ${mode} access to ${path3}. Allow? (y/n/always): `
+    );
+    if (response.toLowerCase() === "always") {
+      this.addScope(path3, mode === "read", mode === "write");
+      return { allowed: true };
+    }
+    if (response.toLowerCase() === "y" || response.toLowerCase() === "yes") {
+      return { allowed: true };
+    }
+    return { allowed: false, reason: `Permission denied for ${mode} access to ${path3}` };
+  }
+  matchPattern(command, pattern) {
+    const regexStr = "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$";
+    try {
+      return new RegExp(regexStr, "i").test(command);
+    } catch {
+      return command.startsWith(pattern.replace(/ \*$/, ""));
+    }
+  }
+  hasPathBeyondCwd(command) {
+    const pathPatterns = [
+      /(?:^|\s)(\/[^\s]+)/,
+      /(?:^|\s)(~\/[^\s]+)/,
+      /(?:^|\s)\.\.\/([^\s]+)/
+    ];
+    for (const p of pathPatterns) {
+      const match = command.match(p);
+      if (match) {
+        const candidate = resolve(match[1].replace(/^~/, homedir2()));
+        if (!candidate.startsWith(this.cwd)) {
+          return candidate;
+        }
+      }
+    }
+    return null;
+  }
+  mergeDefaults(parsed) {
+    return {
+      capabilities: {
+        filesystem: {
+          enabled: parsed.capabilities?.filesystem?.enabled ?? DEFAULT_MANIFEST.capabilities.filesystem.enabled,
+          scopes: parsed.capabilities?.filesystem?.scopes ?? DEFAULT_MANIFEST.capabilities.filesystem.scopes
+        },
+        shell: {
+          enabled: parsed.capabilities?.shell?.enabled ?? DEFAULT_MANIFEST.capabilities.shell.enabled,
+          blocked: parsed.capabilities?.shell?.blocked ?? DEFAULT_MANIFEST.capabilities.shell.blocked,
+          autoApproved: parsed.capabilities?.shell?.autoApproved ?? DEFAULT_MANIFEST.capabilities.shell.autoApproved,
+          needsApproval: parsed.capabilities?.shell?.needsApproval ?? DEFAULT_MANIFEST.capabilities.shell.needsApproval,
+          cwdOnly: parsed.capabilities?.shell?.cwdOnly ?? DEFAULT_MANIFEST.capabilities.shell.cwdOnly
+        },
+        git: {
+          enabled: parsed.capabilities?.git?.enabled ?? DEFAULT_MANIFEST.capabilities.git.enabled,
+          autoApproveRead: parsed.capabilities?.git?.autoApproveRead ?? DEFAULT_MANIFEST.capabilities.git.autoApproveRead,
+          approveWrite: parsed.capabilities?.git?.approveWrite ?? DEFAULT_MANIFEST.capabilities.git.approveWrite
+        }
+      }
+    };
+  }
+};
+
+// src/capabilities/filesystem/read-file.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve2 } from "path";
+function createReadFileTool(permissions) {
+  return tool({
+    description: "Read the contents of a file. The path must be within an allowed scope.",
+    parameters: z.object({
+      path: z.string().describe("Absolute or relative path to the file")
+    }),
+    execute: async ({ path: path3 }) => {
+      const resolved = resolve2(path3);
+      const check = await permissions.checkFsAccess(resolved, "read");
+      if (!check.allowed) {
+        return `Error: ${check.reason}`;
+      }
+      if (!existsSync7(resolved)) {
+        return `Error: File not found: ${resolved}`;
+      }
+      try {
+        const stat = await import("fs").then((m) => m.statSync(resolved));
+        if (stat.isDirectory()) {
+          return `Error: ${resolved} is a directory, not a file. Use list_dir instead.`;
+        }
+        if (stat.size > 1024 * 1024) {
+          return `Error: File too large (${Math.round(stat.size / 1024)}KB). Maximum is 1MB.`;
+        }
+        return readFileSync7(resolved, "utf-8");
+      } catch (err) {
+        return `Error reading file: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/filesystem/write-file.ts
+import { tool as tool2 } from "ai";
+import { z as z2 } from "zod";
+import { existsSync as existsSync8, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve3 } from "path";
+function createWriteFileTool(permissions) {
+  return tool2({
+    description: "Write content to an existing file. The path must be within a writable scope.",
+    parameters: z2.object({
+      path: z2.string().describe("Absolute or relative path to the file"),
+      content: z2.string().describe("The content to write to the file")
+    }),
+    execute: async ({ path: path3, content }) => {
+      const resolved = resolve3(path3);
+      const check = await permissions.checkFsAccess(resolved, "write");
+      if (!check.allowed) {
+        return `Error: ${check.reason}`;
+      }
+      if (!existsSync8(resolved)) {
+        return `Error: File not found: ${resolved}. Use create_file to create new files.`;
+      }
+      try {
+        writeFileSync7(resolved, content, "utf-8");
+        return `Successfully wrote ${content.length} bytes to ${resolved}`;
+      } catch (err) {
+        return `Error writing file: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/filesystem/create-file.ts
+import { tool as tool3 } from "ai";
+import { z as z3 } from "zod";
+import { existsSync as existsSync9, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve4, dirname as dirname2 } from "path";
+function createCreateFileTool(permissions) {
+  return tool3({
+    description: "Create a new file with the given content. Also creates parent directories if needed. The path must be within a writable scope.",
+    parameters: z3.object({
+      path: z3.string().describe("Absolute or relative path for the new file"),
+      content: z3.string().describe("The content of the new file")
+    }),
+    execute: async ({ path: path3, content }) => {
+      const resolved = resolve4(path3);
+      const check = await permissions.checkFsAccess(resolved, "write");
+      if (!check.allowed) {
+        return `Error: ${check.reason}`;
+      }
+      if (existsSync9(resolved)) {
+        return `Error: File already exists: ${resolved}. Use write_file to modify existing files.`;
+      }
+      try {
+        const dir = dirname2(resolved);
+        if (!existsSync9(dir)) {
+          mkdirSync7(dir, { recursive: true });
+        }
+        writeFileSync8(resolved, content, "utf-8");
+        return `Successfully created ${resolved} (${content.length} bytes)`;
+      } catch (err) {
+        return `Error creating file: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/filesystem/list-dir.ts
+import { tool as tool4 } from "ai";
+import { z as z4 } from "zod";
+import { existsSync as existsSync10, readdirSync as readdirSync2, statSync } from "fs";
+import { resolve as resolve5 } from "path";
+function createListDirTool(permissions) {
+  return tool4({
+    description: "List the contents of a directory. Shows file names, types, and sizes.",
+    parameters: z4.object({
+      path: z4.string().describe("Absolute or relative path to the directory")
+    }),
+    execute: async ({ path: path3 }) => {
+      const resolved = resolve5(path3);
+      const check = await permissions.checkFsAccess(resolved, "read");
+      if (!check.allowed) {
+        return `Error: ${check.reason}`;
+      }
+      if (!existsSync10(resolved)) {
+        return `Error: Directory not found: ${resolved}`;
+      }
+      try {
+        const stat = statSync(resolved);
+        if (!stat.isDirectory()) {
+          return `Error: ${resolved} is a file, not a directory. Use read_file instead.`;
+        }
+        const entries = readdirSync2(resolved, { withFileTypes: true });
+        const lines = entries.map((entry) => {
+          const isDir = entry.isDirectory();
+          const fullPath = join7(resolved, entry.name);
+          let size = "";
+          try {
+            if (!isDir) {
+              size = ` (${formatSize(statSync(fullPath).size)})`;
+            }
+          } catch {
+          }
+          return `${isDir ? "\u{1F4C1}" : "\u{1F4C4}"} ${entry.name}${size}`;
+        });
+        if (lines.length === 0) {
+          return `Directory ${resolved} is empty`;
+        }
+        return `Contents of ${resolved} (${entries.length} items):
+${lines.join("\n")}`;
+      } catch (err) {
+        return `Error listing directory: ${err.message}`;
+      }
+    }
+  });
+}
+function join7(base, name) {
+  return base.endsWith("/") ? base + name : base + "/" + name;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// src/capabilities/filesystem/delete-file.ts
+import { tool as tool5 } from "ai";
+import { z as z5 } from "zod";
+import { existsSync as existsSync11, unlinkSync as unlinkSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+function createDeleteFileTool(permissions) {
+  return tool5({
+    description: "Delete a file. This action cannot be undone. The path must be within a writable scope. Always asks for confirmation.",
+    parameters: z5.object({
+      path: z5.string().describe("Absolute or relative path to the file to delete")
+    }),
+    execute: async ({ path: path3 }) => {
+      const resolved = resolve6(path3);
+      const check = await permissions.checkFsAccess(resolved, "write");
+      if (!check.allowed) {
+        return `Error: ${check.reason}`;
+      }
+      if (!existsSync11(resolved)) {
+        return `Error: File not found: ${resolved}`;
+      }
+      try {
+        const stat = await import("fs").then((m) => m.statSync(resolved));
+        if (stat.isDirectory()) {
+          return `Error: ${resolved} is a directory. Cannot delete directories for safety.`;
+        }
+        unlinkSync2(resolved);
+        return `Successfully deleted ${resolved}`;
+      } catch (err) {
+        return `Error deleting file: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/filesystem/edit-file.ts
+import { tool as tool6 } from "ai";
+import { z as z6 } from "zod";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "fs";
+import { resolve as resolve7 } from "path";
+function createEditFileTool(permissions) {
+  return tool6({
+    description: "Edit a file by replacing an exact string match with new content. Use this instead of write_file when you only need to change part of a file. The old_string must match exactly (including whitespace and indentation). Fails if old_string is not found or found multiple times.",
+    parameters: z6.object({
+      path: z6.string().describe("Absolute or relative path to the file"),
+      old_string: z6.string().describe("The exact text to find in the file (must match exactly)"),
+      new_string: z6.string().describe("The text to replace it with")
+    }),
+    execute: async ({ path: path3, old_string, new_string }) => {
+      const resolved = resolve7(path3);
+      const fsCheck = await permissions.checkFsAccess(resolved, "write");
+      if (!fsCheck.allowed) {
+        return `Error: ${fsCheck.reason}`;
+      }
+      try {
+        const content = readFileSync9(resolved, "utf-8");
+        const count = content.split(old_string).length - 1;
+        if (count === 0) {
+          return `Error: old_string not found in ${path3}. Make sure the text matches exactly, including whitespace and indentation.`;
+        }
+        if (count > 1) {
+          return `Error: old_string found ${count} times in ${path3}. Provide more surrounding context to make the match unique.`;
+        }
+        const newContent = content.replace(old_string, new_string);
+        writeFileSync9(resolved, newContent, "utf-8");
+        const linesAdded = new_string.split("\n").length;
+        const linesRemoved = old_string.split("\n").length;
+        return `Edited ${path3}: replaced ${linesRemoved} line(s) with ${linesAdded} line(s)`;
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          return `Error: File not found: ${path3}. Use create_file to create new files.`;
+        }
+        return `Error editing file: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/filesystem/send-file.ts
+import { tool as tool7 } from "ai";
+import { z as z7 } from "zod";
+import { existsSync as existsSync12, statSync as statSync2 } from "fs";
+import { resolve as resolve8, basename } from "path";
+function createSendFileTool(permissions, sendFile) {
+  return tool7({
+    description: "Send a file to the user. On Telegram the file is uploaded as an attachment. On CLI the file path and size are displayed. The path must be within an allowed read scope.",
+    parameters: z7.object({
+      path: z7.string().describe("Absolute or relative path to the file to send")
+    }),
+    execute: async ({ path: path3 }) => {
+      const resolved = resolve8(path3);
+      const check = await permissions.checkFsAccess(resolved, "read");
+      if (!check.allowed) {
+        return `Error: ${check.reason}`;
+      }
+      if (!existsSync12(resolved)) {
+        return `Error: File not found: ${resolved}`;
+      }
+      const stat = statSync2(resolved);
+      if (stat.isDirectory()) {
+        return `Error: ${resolved} is a directory, not a file. Use list_dir to show its contents.`;
+      }
+      if (stat.size > 50 * 1024 * 1024) {
+        return `Error: File too large (${Math.round(stat.size / (1024 * 1024))}MB). Maximum is 50MB.`;
+      }
+      try {
+        await sendFile(resolved);
+        const filename = basename(resolved);
+        const sizeStr = stat.size > 1024 * 1024 ? `${(stat.size / (1024 * 1024)).toFixed(1)}MB` : `${Math.round(stat.size / 1024)}KB`;
+        return `File sent: ${filename} (${sizeStr})`;
+      } catch (err) {
+        return `Error sending file: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/shell/run-command.ts
+import { tool as tool8 } from "ai";
+import { z as z8 } from "zod";
+import { execSync } from "child_process";
+function createRunCommandTool(permissions) {
+  return tool8({
+    description: `Run a shell command. Commands run in the current working directory unless an absolute path is given.
+Blocked commands (sudo, rm -rf /, etc.) are never executed.
+Auto-approved commands (ls, cat, git status, curl, etc.) run without asking.
+Other commands require user approval \u2014 tell the user what command you want to run and ask for confirmation. If they say "yes", try again. If they say "always", use the approve_command tool.`,
+    parameters: z8.object({
+      command: z8.string().describe("The shell command to execute")
+    }),
+    execute: async ({ command }) => {
+      const check = await permissions.checkShellCommand(command);
+      if (!check.allowed) {
+        if (check.needsApproval) {
+          const baseCmd = command.trim().split(/\s+/)[0];
+          permissions.addPendingApproval(baseCmd);
+          return `\u26A0 Command requires approval: ${command}
+
+Tell the user what this command does and ask for permission. If they approve, try running it again. If they say "always", use the approve_command tool to permanently approve this command type.`;
+        }
+        return `Error: ${check.reason}`;
+      }
+      try {
+        logger.info({ cmd: command }, "Executing shell command");
+        const result = execSync(command, {
+          cwd: process.cwd(),
+          timeout: 3e4,
+          maxBuffer: 1024 * 1024,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        const output = result?.trim() || "(no output)";
+        return output;
+      } catch (err) {
+        const stderr = err.stderr?.trim();
+        const stdout = err.stdout?.trim();
+        let msg = `Command exited with code ${err.status || "unknown"}`;
+        if (stdout) msg += `
+Output: ${stdout}`;
+        if (stderr) msg += `
+Error: ${stderr}`;
+        return msg;
+      }
+    }
+  });
+}
+
+// src/capabilities/shell/approve-command.ts
+import { tool as tool9 } from "ai";
+import { z as z9 } from "zod";
+function createApproveCommandTool(permissions) {
+  return tool9({
+    description: 'Permanently approve a command type so it runs without asking in the future. Use this when the user says "always" or "always approve" for a command. For example, if the user says "always approve curl", call this with command="curl".',
+    parameters: z9.object({
+      command: z9.string().describe('The base command to permanently approve (e.g. "curl", "docker", "npm")')
+    }),
+    execute: async ({ command }) => {
+      const baseCmd = command.trim().split(/\s+/)[0];
+      permissions.addApprovedCommand(baseCmd);
+      return `Command "${baseCmd}" has been permanently approved. Future calls to "${baseCmd} ..." will run without asking.`;
+    }
+  });
+}
+
+// src/capabilities/skills/install-skill.ts
+import { tool as tool10 } from "ai";
+import { z as z10 } from "zod";
+import { parse as parseYaml4 } from "yaml";
+function createInstallSkillTool(skillLoader) {
+  return tool10({
+    description: "Install a new skill by providing SKILL.md markdown content or a URL. The content must have YAML frontmatter (---) with at least name and description fields.",
+    parameters: z10.object({
+      content: z10.string().optional().describe("Raw SKILL.md markdown content with YAML frontmatter"),
+      url: z10.string().optional().describe("URL to fetch a SKILL.md from")
+    }),
+    execute: async ({ content, url }) => {
+      let skillContent;
+      if (url && !content) {
+        try {
+          const resp = await fetch(url);
+          if (!resp.ok) {
+            return `Failed to fetch skill from URL: ${resp.status} ${resp.statusText}`;
+          }
+          skillContent = await resp.text();
+        } catch (err) {
+          return `Failed to fetch skill from URL: ${err.message}`;
+        }
+      } else if (content) {
+        skillContent = content;
+      } else {
+        return "Either content or url must be provided.";
+      }
+      const fmMatch = skillContent.match(/^---\s*\n([\s\S]*?)\n---/);
+      if (!fmMatch) {
+        return "Invalid SKILL.md: missing YAML frontmatter (--- delimiters).";
+      }
+      try {
+        const meta2 = parseYaml4(fmMatch[1]);
+        if (!meta2.name || !meta2.description) {
+          return 'Invalid SKILL.md: frontmatter must include at least "name" and "description".';
+        }
+      } catch {
+        return "Invalid SKILL.md: could not parse YAML frontmatter.";
+      }
+      const fmMatch2 = skillContent.match(/^---\s*\n([\s\S]*?)\n---/);
+      const meta = parseYaml4(fmMatch2[1]);
+      const skillDir = skillLoader.saveSkill(meta.name, skillContent);
+      return `Skill "${meta.name}" installed to ${skillDir}. Use list_skills to see all installed skills, or use_skill to invoke it.`;
+    }
+  });
+}
+
+// src/capabilities/skills/list-skills.ts
+import { tool as tool11 } from "ai";
+import { z as z11 } from "zod";
+function createListSkillsTool(skillLoader) {
+  return tool11({
+    description: "List all installed skills with their names and descriptions.",
+    parameters: z11.object({}),
+    execute: async () => {
+      const skills = skillLoader.getDiscovered();
+      if (skills.length === 0) {
+        return "No skills installed. Use install_skill to add one.";
+      }
+      return skills.map((s) => `${s.name}: ${s.description}`).join("\n");
+    }
+  });
+}
+
+// src/capabilities/skills/use-skill.ts
+import { tool as tool12 } from "ai";
+import { z as z12 } from "zod";
+function createUseSkillTool(skillLoader, permissions) {
+  return tool12({
+    description: "Load and invoke a skill by name. Returns the skill's full instructions which should be followed as guidance for the current task.",
+    parameters: z12.object({
+      name: z12.string().describe("Name of the skill to invoke")
+    }),
+    execute: async ({ name }) => {
+      const skill = skillLoader.load(name);
+      if (!skill) {
+        return `Skill "${name}" not found. Use list_skills to see available skills.`;
+      }
+      if (skill["allowed-tools"] && skill["allowed-tools"].length > 0) {
+        permissions.elevateForSkill(skill["allowed-tools"]);
+      }
+      let result = `## Skill: ${skill.name}
+
+${skill.instructions}`;
+      if (skill["allowed-tools"] && skill["allowed-tools"].length > 0) {
+        result += `
+
+Allowed tools: ${skill["allowed-tools"].join(", ")}`;
+      }
+      if (skill["disable-model-invocation"]) {
+        result += "\n\nNote: This skill has model invocation disabled. Follow instructions only.";
+      }
+      return result;
+    }
+  });
+}
+
+// src/capabilities/scheduler/schedule-task.ts
+import { tool as tool13 } from "ai";
+import { z as z13 } from "zod";
+import cron2 from "node-cron";
+function createScheduleTaskTool(scheduler, getContext) {
+  return tool13({
+    description: 'Schedule a task. Use "cron" for recurring tasks (e.g. "0 9 * * *" for daily at 9am) or "delay_seconds" for one-shot delayed tasks (e.g. 15 for "remind me in 15 seconds"). Provide exactly one of cron or delay_seconds.',
+    parameters: z13.object({
+      cron: z13.string().optional().describe('Cron expression for recurring tasks (e.g. "0 9 * * *" for daily at 9am)'),
+      delay_seconds: z13.number().optional().describe('Delay in seconds for one-shot tasks (e.g. 15 for "remind me in 15 seconds")'),
+      description: z13.string().describe("Human-readable description of what this task does"),
+      prompt: z13.string().optional().describe("Prompt to send to the agent when the task fires"),
+      skill_name: z13.string().optional().describe("Name of a skill to invoke when the task fires")
+    }),
+    execute: async ({ cron: cronExpr, delay_seconds, description, prompt, skill_name }) => {
+      if (!cronExpr && !delay_seconds) {
+        return "Either cron or delay_seconds must be provided.";
+      }
+      if (cronExpr && delay_seconds) {
+        return "Provide either cron or delay_seconds, not both.";
+      }
+      if (!prompt && !skill_name) {
+        return "Either prompt or skill_name must be provided so the task has something to do.";
+      }
+      const id = `task-${Date.now().toString(36)}`;
+      const ctx = getContext();
+      if (delay_seconds) {
+        const manifest2 = {
+          id,
+          description,
+          prompt,
+          skillName: skill_name,
+          delaySeconds: delay_seconds,
+          executeAt: new Date(Date.now() + delay_seconds * 1e3).toISOString(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          sourceChannelId: ctx.channelId,
+          sourceChannelType: ctx.channelType
+        };
+        scheduler.addDelayedTask(manifest2);
+        scheduler.persistSchedules();
+        const triggerType2 = skill_name ? `skill: ${skill_name}` : `prompt: "${prompt.slice(0, 60)}"`;
+        return `Reminder "${id}" set. Will trigger in ${delay_seconds} second${delay_seconds !== 1 ? "s" : ""}. ${triggerType2}. Description: ${description}`;
+      }
+      if (!cron2.validate(cronExpr)) {
+        return `Invalid cron expression: "${cronExpr}". Use standard 5-field cron format (min hour day month weekday).`;
+      }
+      const manifest = {
+        id,
+        cron: cronExpr,
+        description,
+        prompt,
+        skillName: skill_name,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceChannelId: ctx.channelId,
+        sourceChannelType: ctx.channelType
+      };
+      scheduler.addPersistedTask(manifest);
+      scheduler.persistSchedules();
+      const triggerType = skill_name ? `skill: ${skill_name}` : `prompt: "${prompt.slice(0, 60)}"`;
+      return `Task "${id}" scheduled. Cron: ${cronExpr}. Will execute ${triggerType}. Description: ${description}`;
+    }
+  });
+}
+
+// src/capabilities/scheduler/list-tasks.ts
+import { tool as tool14 } from "ai";
+import { z as z14 } from "zod";
+function createListTasksTool(scheduler) {
+  return tool14({
+    description: "List all scheduled tasks with their cron expressions and descriptions.",
+    parameters: z14.object({}),
+    execute: async () => {
+      const manifests = scheduler.getManifests();
+      if (manifests.length === 0) {
+        return "No scheduled tasks. Use schedule_task to create one.";
+      }
+      return manifests.map((m) => {
+        const trigger = m.skillName ? `skill: ${m.skillName}` : m.prompt ? `prompt: "${m.prompt.slice(0, 40)}"` : "no action";
+        return `${m.id} | ${m.cron} | ${m.description} | ${trigger}`;
+      }).join("\n");
+    }
+  });
+}
+
+// src/capabilities/scheduler/cancel-task.ts
+import { tool as tool15 } from "ai";
+import { z as z15 } from "zod";
+function createCancelTaskTool(scheduler) {
+  return tool15({
+    description: "Cancel and remove a scheduled task by its ID.",
+    parameters: z15.object({
+      id: z15.string().describe("ID of the scheduled task to cancel")
+    }),
+    execute: async ({ id }) => {
+      const manifests = scheduler.getManifests();
+      const exists = manifests.some((m) => m.id === id);
+      if (!exists) {
+        return `Task "${id}" not found. Use list_scheduled_tasks to see active tasks.`;
+      }
+      scheduler.removeTask(id);
+      scheduler.persistSchedules();
+      return `Task "${id}" cancelled and removed.`;
+    }
+  });
+}
+
+// src/capabilities/system/budget-status.ts
+import { tool as tool16 } from "ai";
+import { z as z16 } from "zod";
+function createBudgetStatusTool(tokenBudget) {
+  return tool16({
+    description: "Check the current token budget status \u2014 how many tokens have been used today, how many remain, and what percentage is consumed.",
+    parameters: z16.object({}),
+    execute: async () => {
+      return tokenBudget.getStatusText();
+    }
+  });
+}
+
+// src/capabilities/git/git-status.ts
+import { tool as tool17 } from "ai";
+import { z as z17 } from "zod";
+import { execSync as execSync2 } from "child_process";
+function createGitStatusTool() {
+  return tool17({
+    description: "Show the working tree status. Returns staged, unstaged, and untracked files.",
+    parameters: z17.object({
+      path: z17.string().optional().describe("Path to check (defaults to current directory)")
+    }),
+    execute: async ({ path: path3 }) => {
+      try {
+        const cmd = path3 ? `git -C "${path3}" status --porcelain` : "git status --porcelain";
+        const result = execSync2(cmd, { encoding: "utf-8", timeout: 1e4 });
+        if (!result.trim()) return "Working tree clean \u2014 no changes.";
+        return result.trim();
+      } catch (err) {
+        return `Error: ${err.stderr?.trim() || err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/git/git-diff.ts
+import { tool as tool18 } from "ai";
+import { z as z18 } from "zod";
+import { execSync as execSync3 } from "child_process";
+function createGitDiffTool() {
+  return tool18({
+    description: "Show changes between commits, commit and working tree, etc. Shows what has been modified.",
+    parameters: z18.object({
+      path: z18.string().optional().describe("File or directory to diff"),
+      staged: z18.boolean().optional().describe("Show staged changes (cached) instead of unstaged")
+    }),
+    execute: async ({ path: path3, staged }) => {
+      try {
+        let cmd = "git diff";
+        if (staged) cmd += " --cached";
+        if (path3) cmd += ` -- "${path3}"`;
+        const result = execSync3(cmd, { encoding: "utf-8", timeout: 15e3 });
+        if (!result.trim()) return "No differences found.";
+        const truncated = result.length > 15e3 ? result.slice(0, 15e3) + "\n... (truncated)" : result;
+        return truncated;
+      } catch (err) {
+        return `Error: ${err.stderr?.trim() || err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/git/git-log.ts
+import { tool as tool19 } from "ai";
+import { z as z19 } from "zod";
+import { execSync as execSync4 } from "child_process";
+function createGitLogTool() {
+  return tool19({
+    description: "Show commit logs. Returns recent commit history with hash, author, date, and message.",
+    parameters: z19.object({
+      count: z19.number().optional().describe("Number of commits to show (default 10)"),
+      path: z19.string().optional().describe("File or directory to show log for")
+    }),
+    execute: async ({ count, path: path3 }) => {
+      try {
+        const n = count ?? 10;
+        let cmd = `git log --oneline --decorate -${n}`;
+        if (path3) cmd += ` -- "${path3}"`;
+        const result = execSync4(cmd, { encoding: "utf-8", timeout: 1e4 });
+        if (!result.trim()) return "No commits found.";
+        return result.trim();
+      } catch (err) {
+        return `Error: ${err.stderr?.trim() || err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/git/git-add.ts
+import { tool as tool20 } from "ai";
+import { z as z20 } from "zod";
+import { execSync as execSync5 } from "child_process";
+function createGitAddTool() {
+  return tool20({
+    description: "Add file contents to the index (staging area). Prepares files for commit.",
+    parameters: z20.object({
+      paths: z20.array(z20.string()).describe("File paths to stage")
+    }),
+    execute: async ({ paths }) => {
+      try {
+        const fileArgs = paths.map((p) => `"${p}"`).join(" ");
+        const result = execSync5(`git add ${fileArgs}`, { encoding: "utf-8", timeout: 1e4 });
+        return `Staged ${paths.length} file(s): ${paths.join(", ")}`;
+      } catch (err) {
+        return `Error: ${err.stderr?.trim() || err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/git/git-commit.ts
+import { tool as tool21 } from "ai";
+import { z as z21 } from "zod";
+import { execSync as execSync6 } from "child_process";
+function createGitCommitTool() {
+  return tool21({
+    description: "Record changes to the repository. Creates a new commit with staged changes.",
+    parameters: z21.object({
+      message: z21.string().describe("Commit message")
+    }),
+    execute: async ({ message }) => {
+      try {
+        const escapedMsg = message.replace(/"/g, '\\"');
+        const result = execSync6(`git commit -m "${escapedMsg}"`, { encoding: "utf-8", timeout: 1e4 });
+        return result.trim() || "Committed successfully.";
+      } catch (err) {
+        const stderr = err.stderr?.trim() || "";
+        if (stderr.includes("nothing to commit")) {
+          return "Nothing to commit \u2014 no staged changes.";
+        }
+        return `Error: ${stderr || err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/git/git-push.ts
+import { tool as tool22 } from "ai";
+import { z as z22 } from "zod";
+import { execSync as execSync7 } from "child_process";
+function createGitPushTool(permissions) {
+  return tool22({
+    description: "Push commits to a remote repository. This modifies a remote and requires approval.",
+    parameters: z22.object({
+      remote: z22.string().optional().describe("Remote name (default: origin)"),
+      branch: z22.string().optional().describe("Branch name (default: current branch)")
+    }),
+    execute: async ({ remote, branch }) => {
+      const cmd = `git push ${remote || "origin"} ${branch || ""}`.trim();
+      const check = await permissions.checkShellCommand(cmd);
+      if (!check.allowed && check.needsApproval) {
+        const baseCmd = "git";
+        permissions.addPendingApproval(baseCmd);
+        return `\u26A0 This command pushes to a remote: ${cmd}
+Ask the user for permission. If they approve, try again. If they say "always", use the approve_command tool.`;
+      }
+      if (!check.allowed) {
+        return `Error: ${check.reason}`;
+      }
+      try {
+        const result = execSync7(cmd, { encoding: "utf-8", timeout: 3e4 });
+        return result.trim() || "Pushed successfully.";
+      } catch (err) {
+        return `Error: ${err.stderr?.trim() || err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/web/fetch-url.ts
+import { tool as tool23 } from "ai";
+import { z as z23 } from "zod";
+var MAX_CONTENT_LENGTH = 15e3;
+function stripHtml(html) {
+  let text = html;
+  text = text.replace(/<script[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<style[\s\S]*?<\/style>/gi, "");
+  text = text.replace(/<nav[\s\S]*?<\/nav>/gi, "");
+  text = text.replace(/<footer[\s\S]*?<\/footer>/gi, "");
+  text = text.replace(/<header[\s\S]*?<\/header>/gi, "");
+  text = text.replace(/<br\s*\/?>/gi, "\n");
+  text = text.replace(/<\/p>/gi, "\n");
+  text = text.replace(/<\/h[1-6]>/gi, "\n");
+  text = text.replace(/<\/li>/gi, "\n");
+  text = text.replace(/<\/div>/gi, "\n");
+  text = text.replace(/<hr\s*\/?>/gi, "\n---\n");
+  text = text.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)");
+  text = text.replace(/<img[^>]*alt="([^"]*)"[^>]*>/gi, "[image: $1]");
+  text = text.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, "`$1`");
+  text = text.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, "\n```\n$1\n```\n");
+  text = text.replace(/<strong[^>]*>([\s\S]*?)<\/strong>/gi, "**$1**");
+  text = text.replace(/<em[^>]*>([\s\S]*?)<\/em>/gi, "*$1*");
+  text = text.replace(/<[^>]+>/g, "");
+  text = text.replace(/&amp;/g, "&");
+  text = text.replace(/&lt;/g, "<");
+  text = text.replace(/&gt;/g, ">");
+  text = text.replace(/&quot;/g, '"');
+  text = text.replace(/&#39;/g, "'");
+  text = text.replace(/&nbsp;/g, " ");
+  text = text.replace(/\n{3,}/g, "\n\n");
+  text = text.trim();
+  return text;
+}
+function createFetchUrlTool() {
+  return tool23({
+    description: "Fetch a URL and return its content as text. Strips HTML to readable markdown-like format. Useful for reading documentation, APIs, or web pages.",
+    parameters: z23.object({
+      url: z23.string().describe("The URL to fetch"),
+      format: z23.enum(["text", "markdown"]).optional().describe("Output format (default: markdown)")
+    }),
+    execute: async ({ url, format }) => {
+      const outputFormat = format ?? "markdown";
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15e3);
+        const resp = await fetch(url, {
+          signal: controller.signal,
+          headers: {
+            "User-Agent": "Mercury-Agent/0.1.0",
+            "Accept": "text/html,application/json,text/plain"
+          }
+        });
+        clearTimeout(timeout);
+        if (!resp.ok) {
+          return `HTTP ${resp.status} ${resp.statusText} for ${url}`;
+        }
+        const contentType = resp.headers.get("content-type") || "";
+        const body = await resp.text();
+        if (contentType.includes("application/json")) {
+          try {
+            const json = JSON.parse(body);
+            const formatted = JSON.stringify(json, null, 2);
+            return formatted.length > MAX_CONTENT_LENGTH ? formatted.slice(0, MAX_CONTENT_LENGTH) + "\n... (truncated)" : formatted;
+          } catch {
+            return body.slice(0, MAX_CONTENT_LENGTH);
+          }
+        }
+        if (contentType.includes("text/html") && outputFormat === "markdown") {
+          const text = stripHtml(body);
+          return text.length > MAX_CONTENT_LENGTH ? text.slice(0, MAX_CONTENT_LENGTH) + "\n... (truncated)" : text;
+        }
+        return body.length > MAX_CONTENT_LENGTH ? body.slice(0, MAX_CONTENT_LENGTH) + "\n... (truncated)" : body;
+      } catch (err) {
+        if (err.name === "AbortError") {
+          return `Request to ${url} timed out after 15 seconds.`;
+        }
+        return `Error fetching ${url}: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/capabilities/registry.ts
+var CapabilityRegistry = class {
+  permissions;
+  tools = {};
+  skillLoader;
+  scheduler;
+  tokenBudget;
+  sendFileHandler;
+  currentChannelId = "cli";
+  currentChannelType = "cli";
+  constructor(skillLoader, scheduler, tokenBudget) {
+    this.permissions = new PermissionManager();
+    this.skillLoader = skillLoader;
+    this.scheduler = scheduler;
+    this.tokenBudget = tokenBudget;
+  }
+  setChannelContext(channelId, channelType) {
+    this.currentChannelId = channelId;
+    this.currentChannelType = channelType;
+  }
+  getChannelContext() {
+    return { channelId: this.currentChannelId, channelType: this.currentChannelType };
+  }
+  setSendFileHandler(handler) {
+    this.sendFileHandler = handler;
+  }
+  registerAll() {
+    const manifest = this.permissions.getManifest();
+    if (manifest.capabilities.filesystem.enabled) {
+      this.tools.read_file = createReadFileTool(this.permissions);
+      this.tools.write_file = createWriteFileTool(this.permissions);
+      this.tools.create_file = createCreateFileTool(this.permissions);
+      this.tools.list_dir = createListDirTool(this.permissions);
+      this.tools.delete_file = createDeleteFileTool(this.permissions);
+      this.tools.edit_file = createEditFileTool(this.permissions);
+      if (this.sendFileHandler) {
+        this.tools.send_file = createSendFileTool(this.permissions, this.sendFileHandler);
+      }
+      logger.info("Filesystem tools registered");
+    }
+    if (manifest.capabilities.shell.enabled) {
+      this.tools.run_command = createRunCommandTool(this.permissions);
+      this.tools.approve_command = createApproveCommandTool(this.permissions);
+      logger.info("Shell tools registered");
+    }
+    if (this.skillLoader) {
+      this.tools.install_skill = createInstallSkillTool(this.skillLoader);
+      this.tools.list_skills = createListSkillsTool(this.skillLoader);
+      this.tools.use_skill = createUseSkillTool(this.skillLoader, this.permissions);
+      logger.info("Skill tools registered");
+    }
+    if (this.scheduler) {
+      this.tools.schedule_task = createScheduleTaskTool(this.scheduler, () => this.getChannelContext());
+      this.tools.list_scheduled_tasks = createListTasksTool(this.scheduler);
+      this.tools.cancel_scheduled_task = createCancelTaskTool(this.scheduler);
+      logger.info("Scheduler tools registered");
+    }
+    if (this.tokenBudget) {
+      this.tools.budget_status = createBudgetStatusTool(this.tokenBudget);
+      logger.info("Budget tool registered");
+    }
+    if (manifest.capabilities.git?.enabled) {
+      this.tools.git_status = createGitStatusTool();
+      this.tools.git_diff = createGitDiffTool();
+      this.tools.git_log = createGitLogTool();
+      this.tools.git_add = createGitAddTool();
+      this.tools.git_commit = createGitCommitTool();
+      this.tools.git_push = createGitPushTool(this.permissions);
+      logger.info("Git tools registered");
+    }
+    this.tools.fetch_url = createFetchUrlTool();
+    logger.info("Web fetch tool registered");
+  }
+  getTools() {
+    return this.tools;
+  }
+  getToolNames() {
+    return Object.keys(this.tools);
+  }
+  getSkillContext() {
+    return this.skillLoader?.getSkillSummariesText() || "";
+  }
+};
+
+// src/skills/loader.ts
+import { existsSync as existsSync13, readFileSync as readFileSync10, readdirSync as readdirSync3, mkdirSync as mkdirSync8, writeFileSync as writeFileSync10 } from "fs";
+import { join as join8 } from "path";
+import { parse as parseYaml5 } from "yaml";
+var SKILL_FILE = "SKILL.md";
+function parseSkillMd(content) {
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+  if (!fmMatch) return null;
+  try {
+    const meta = parseYaml5(fmMatch[1]);
+    const instructions = fmMatch[2].trim();
+    if (!meta.name || !meta.description) {
+      logger.warn({ meta }, "SKILL.md missing required fields (name, description)");
+      return null;
+    }
+    return { meta, instructions };
+  } catch (err) {
+    logger.warn({ err }, "Failed to parse SKILL.md frontmatter");
+    return null;
+  }
+}
+var SkillLoader = class {
+  skillsDir;
+  discovered = /* @__PURE__ */ new Map();
+  loaded = /* @__PURE__ */ new Map();
+  constructor(skillsDir) {
+    this.skillsDir = skillsDir || join8(getMercuryHome(), "skills");
+  }
+  discover() {
+    this.discovered.clear();
+    this.loaded.clear();
+    if (!existsSync13(this.skillsDir)) {
+      mkdirSync8(this.skillsDir, { recursive: true });
+      this.seedTemplate();
+      return [];
+    }
+    const entries = readdirSync3(this.skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith("_")) continue;
+      const skillPath = join8(this.skillsDir, entry.name, SKILL_FILE);
+      if (!existsSync13(skillPath)) continue;
+      try {
+        const raw = readFileSync10(skillPath, "utf-8");
+        const parsed = parseSkillMd(raw);
+        if (!parsed) continue;
+        this.discovered.set(parsed.meta.name, {
+          name: parsed.meta.name,
+          description: parsed.meta.description
+        });
+        logger.info({ skill: parsed.meta.name }, "Skill discovered");
+      } catch (err) {
+        logger.warn({ dir: entry.name, err }, "Failed to load skill");
+      }
+    }
+    return [...this.discovered.values()];
+  }
+  load(name) {
+    const cached = this.loaded.get(name);
+    if (cached) return cached;
+    for (const entry of readdirSync3(this.skillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith("_")) continue;
+      const skillPath = join8(this.skillsDir, entry.name, SKILL_FILE);
+      if (!existsSync13(skillPath)) continue;
+      try {
+        const raw = readFileSync10(skillPath, "utf-8");
+        const parsed = parseSkillMd(raw);
+        if (!parsed || parsed.meta.name !== name) continue;
+        const skillDir = join8(this.skillsDir, entry.name);
+        const skill = {
+          ...parsed.meta,
+          instructions: parsed.instructions,
+          scriptsDir: existsSync13(join8(skillDir, "scripts")) ? join8(skillDir, "scripts") : void 0,
+          referencesDir: existsSync13(join8(skillDir, "references")) ? join8(skillDir, "references") : void 0
+        };
+        this.loaded.set(name, skill);
+        return skill;
+      } catch (err) {
+        logger.warn({ err, name }, "Failed to load skill");
+        return null;
+      }
+    }
+    return null;
+  }
+  getDiscovered() {
+    return [...this.discovered.values()];
+  }
+  getSkillSummariesText() {
+    const skills = this.getDiscovered();
+    if (skills.length === 0) return "";
+    return "Available skills:\n" + skills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+  }
+  saveSkill(name, content) {
+    const skillDir = join8(this.skillsDir, name);
+    if (!existsSync13(skillDir)) {
+      mkdirSync8(skillDir, { recursive: true });
+    }
+    writeFileSync10(join8(skillDir, SKILL_FILE), content, "utf-8");
+    logger.info({ skill: name }, "Skill saved");
+    this.discover();
+    return skillDir;
+  }
+  seedTemplate() {
+    const templateDir = join8(this.skillsDir, "_template");
+    mkdirSync8(templateDir, { recursive: true });
+    const content = `---
+name: template-skill
+description: A template skill for Mercury. Use this as a starting point to create your own skills.
+version: 0.1.0
+allowed-tools:
+  - read_file
+  - list_dir
+---
+
+# Template Skill
+
+This is a template skill for Mercury. Copy this directory and edit SKILL.md to create your own skill.
+
+## What It Does
+
+Describe what this skill enables Mercury to do. When invoked via the use_skill tool, these instructions are injected into Mercury's context as guidance.
+
+## Instructions
+
+1. Step one of what Mercury should do
+2. Step two
+3. Continue with specific guidance
+
+## Tips
+
+- Keep instructions concise to save tokens
+- List only the tools you need in allowed-tools
+- The skill name must be unique among installed skills
+`;
+    writeFileSync10(join8(templateDir, SKILL_FILE), content, "utf-8");
+    logger.info("Seeded template skill");
+  }
+};
+
+// src/index.ts
+function hr() {
+  console.log(chalk3.dim("\u2500".repeat(50)));
+}
+function banner() {
+  console.log("");
+  const art = figlet.textSync("MERCURY", { font: "Slant", horizontalLayout: "default" });
+  for (const line of art.split("\n")) {
+    if (line.trim()) console.log(chalk3.bold.cyan(`  ${line}`));
+  }
+  console.log("");
+  console.log(chalk3.white("  an AI agent for personal tasks"));
+  console.log(chalk3.dim("  v0.1.0 \xB7 by Cosmic Stack \xB7 mercury.cosmicstack.org"));
+  console.log("");
+}
+function splashScreen() {
+  console.log("");
+  const art = figlet.textSync("MERCURY", { font: "Slant", horizontalLayout: "default" });
+  for (const line of art.split("\n")) {
+    if (line.trim()) console.log(chalk3.bold.cyan(`  ${line}`));
+  }
+  console.log("");
+  console.log(chalk3.dim("  an AI agent for personal tasks"));
+  console.log(chalk3.cyan("  by Cosmic Stack"));
+  console.log(chalk3.dim("  mercury.cosmicstack.org"));
+  console.log("");
+}
+async function ask(prompt) {
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve9) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve9(answer.trim());
+    });
+  });
+}
+async function onboarding() {
+  splashScreen();
+  console.log(chalk3.yellow("  First run detected \u2014 let's set you up."));
+  hr();
+  console.log("");
+  const config = loadConfig();
+  const ownerName = await ask(chalk3.white("  Your name: "));
+  if (!ownerName) {
+    console.log(chalk3.red("  Name is required."));
+    process.exit(1);
+  }
+  config.identity.owner = ownerName;
+  const agentName = await ask(chalk3.white(`  Agent name [${config.identity.name}]: `));
+  if (agentName) config.identity.name = agentName;
+  config.identity.creator = "Cosmic Stack";
+  hr();
+  console.log("");
+  console.log(chalk3.white("  LLM Providers"));
+  console.log(chalk3.dim("  At least one API key is required."));
+  console.log("");
+  const deepseekKey = await ask(chalk3.white("  DeepSeek API key: "));
+  if (deepseekKey) {
+    config.providers.deepseek.apiKey = deepseekKey;
+    config.providers.default = "deepseek";
+  }
+  const openaiKey = await ask(chalk3.white("  OpenAI API key (Enter to skip): "));
+  if (openaiKey) config.providers.openai.apiKey = openaiKey;
+  const anthropicKey = await ask(chalk3.white("  Anthropic API key (Enter to skip): "));
+  if (anthropicKey) config.providers.anthropic.apiKey = anthropicKey;
+  if (!deepseekKey && !openaiKey && !anthropicKey) {
+    console.log(chalk3.red("\n  At least one LLM API key is required."));
+    process.exit(1);
+  }
+  hr();
+  console.log("");
+  console.log(chalk3.white("  Telegram (optional)"));
+  console.log(chalk3.dim("  Leave empty to skip. You can add it later."));
+  console.log("");
+  const telegramToken = await ask(chalk3.white("  Telegram Bot Token: "));
+  if (telegramToken) {
+    config.channels.telegram.botToken = telegramToken;
+    config.channels.telegram.enabled = true;
+  }
+  hr();
+  saveConfig(config);
+  const home = getMercuryHome();
+  console.log("");
+  console.log(chalk3.green(`  \u2713 Config saved to ${home}/mercury.yaml`));
+  console.log(chalk3.green(`  \u2713 Soul files seeded in ${home}/soul/`));
+  console.log(chalk3.green(`  \u2713 Memory stored in ${home}/memory/`));
+  console.log(chalk3.green(`  \u2713 Permissions seeded in ${home}/permissions.yaml`));
+  console.log(chalk3.green(`  \u2713 Skills directory ready in ${home}/skills/`));
+  console.log("");
+  console.log(chalk3.cyan(`  ${config.identity.name} is ready. Run \`mercury start\` to begin.`));
+  console.log(chalk3.dim("  mercury.cosmicstack.org"));
+  console.log("");
+}
+async function runAgent() {
+  let config = loadConfig();
+  config = ensureCreatorField(config);
+  const name = config.identity.name;
+  banner();
+  console.log(chalk3.white(`  ${name} is waking up...`));
+  console.log("");
+  const tokenBudget = new TokenBudget(config);
+  const providers = new ProviderRegistry(config);
+  if (!providers.hasProviders()) {
+    console.log(chalk3.red("  No LLM providers available. Run `mercury setup` to configure API keys."));
+    process.exit(1);
+  }
+  const available = providers.listAvailable();
+  console.log(chalk3.dim(`  Providers: ${available.join(", ")}`));
+  const skillLoader = new SkillLoader();
+  const skills = skillLoader.discover();
+  console.log(chalk3.dim(`  Skills: ${skills.length > 0 ? skills.map((s) => s.name).join(", ") : "none installed"}`));
+  const scheduler = new Scheduler(config);
+  const identity = new Identity();
+  const shortTerm = new ShortTermMemory(config);
+  const longTerm = new LongTermMemory(config);
+  const episodic = new EpisodicMemory(config);
+  const channels = new ChannelRegistry(config);
+  const capabilities = new CapabilityRegistry(skillLoader, scheduler, tokenBudget);
+  capabilities.setSendFileHandler(async (filePath) => {
+    const msg = channels.getActiveChannels().includes("telegram") ? channels.get("telegram") : channels.get("cli");
+    if (msg) {
+      await msg.sendFile(filePath);
+    }
+  });
+  capabilities.registerAll();
+  const agent = new Agent(
+    config,
+    providers,
+    identity,
+    shortTerm,
+    longTerm,
+    episodic,
+    channels,
+    tokenBudget,
+    capabilities,
+    scheduler
+  );
+  await agent.birth();
+  await agent.wake();
+  const cliChannel = channels.get("cli");
+  if (cliChannel) {
+    capabilities.permissions.onAsk(async (prompt) => {
+      return cliChannel.askPermission(prompt);
+    });
+  }
+  const activeCh = channels.getActiveChannels();
+  const toolNames = capabilities.getToolNames();
+  console.log(chalk3.dim(`  Channels: ${activeCh.join(", ")}`));
+  console.log(chalk3.dim(`  Tools: ${toolNames.join(", ")}`));
+  console.log(chalk3.dim(`  Permissions: ${getMercuryHome()}/permissions.yaml`));
+  console.log(chalk3.dim(`  Schedules: ${getMercuryHome()}/schedules.yaml`));
+  if (config.identity.creator) {
+    console.log(chalk3.dim(`  Creator: ${config.identity.creator}`));
+  }
+  hr();
+  console.log("");
+  console.log(chalk3.green(`  ${name} is live. Type a message and press Enter.`));
+  console.log(chalk3.dim("  Ctrl+C to exit."));
+  console.log("");
+  const shutdown = async () => {
+    console.log("");
+    console.log(chalk3.dim(`  ${name} is shutting down...`));
+    await agent.shutdown();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+var program = new Command();
+program.name("mercury").description("Mercury \u2014 an AI agent for personal tasks").version("0.1.0").option("-v, --verbose", "Show debug logs").action(async () => {
+  if (!isSetupComplete()) {
+    await onboarding();
+    return;
+  }
+  await runAgent();
+});
+program.command("start").description("Start Mercury agent").option("-v, --verbose", "Show debug logs").action(async () => {
+  if (!isSetupComplete()) {
+    await onboarding();
+    return;
+  }
+  await runAgent();
+});
+program.command("setup").description("Re-run the setup wizard").action(async () => {
+  await onboarding();
+});
+program.command("status").description("Show current configuration").action(() => {
+  const config = loadConfig();
+  const home = getMercuryHome();
+  const skillLoader = new SkillLoader();
+  const skills = skillLoader.discover();
+  banner();
+  console.log(`  Name:     ${chalk3.cyan(config.identity.name)}`);
+  console.log(`  Owner:    ${chalk3.white(config.identity.owner || "(not set)")}`);
+  if (config.identity.creator) {
+    console.log(`  Creator:  ${chalk3.white(config.identity.creator)}`);
+  }
+  console.log(`  Provider: ${chalk3.white(config.providers.default)}`);
+  console.log(`  Telegram: ${config.channels.telegram.enabled ? chalk3.green("enabled") : chalk3.dim("disabled")}`);
+  console.log(`  Skills:   ${skills.length > 0 ? chalk3.green(skills.map((s) => s.name).join(", ")) : chalk3.dim("none")}`);
+  console.log(`  Budget:   ${chalk3.white(config.tokens.dailyBudget)} tokens/day`);
+  console.log(`  Setup:    ${isSetupComplete() ? chalk3.green("complete") : chalk3.red("not done")}`);
+  console.log(`  Home:     ${chalk3.dim(home)}`);
+  console.log("");
+});
+program.parse();
+//# sourceMappingURL=index.js.map