@cosmicstack/mercury-agent 0.1.0 → 0.2.0

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { Command } from "commander";
 import readline2 from "readline";
-import chalk3 from "chalk";
+import chalk6 from "chalk";
 import figlet from "figlet";
 
 // src/utils/config.ts
@@ -67,7 +67,8 @@ function getDefaultConfig() {
         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)
+        allowedChatIds: getEnv("TELEGRAM_ALLOWED_CHAT_IDS", "").split(",").filter(Boolean).map(Number),
+        streaming: getEnvBool("TELEGRAM_STREAMING", true)
       }
     },
     memory: {
@@ -128,10 +129,6 @@ function deepMerge(target, source) {
   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");
@@ -145,6 +142,8 @@ var logger = pino(
 );
 
 // 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";
 var DEFAULT_SOUL = `# Identity
 
 You are {name}. You are not any underlying model \u2014 you are {name}.
@@ -679,6 +678,7 @@ var Agent = class {
     this.lifecycle = new Lifecycle();
     this.scheduler = scheduler;
     this.capabilities = capabilities;
+    this.telegramStreaming = config.channels.telegram.streaming ?? true;
     this.scheduler.setOnScheduledTask(async (manifest) => this.handleScheduledTask(manifest));
     this.channels.onIncomingMessage((msg) => this.enqueueMessage(msg));
     this.scheduler.onHeartbeat(async () => {
@@ -699,6 +699,7 @@ var Agent = class {
   running = false;
   messageQueue = [];
   processing = false;
+  telegramStreaming;
   enqueueMessage(msg) {
     logger.info({ from: msg.channelType, content: msg.content.slice(0, 50) }, "Message enqueued");
     this.messageQueue.push(msg);
@@ -758,6 +759,43 @@ var Agent = class {
         this.lifecycle.transition("idle");
         return;
       }
+      if (trimmed === "/budget_override") {
+        await this.handleBudgetCommand("override", msg.channelType, msg.channelId);
+        this.lifecycle.transition("idle");
+        return;
+      }
+      if (trimmed === "/budget_reset") {
+        await this.handleBudgetCommand("reset", msg.channelType, msg.channelId);
+        this.lifecycle.transition("idle");
+        return;
+      }
+      if (trimmed.startsWith("/budget_set")) {
+        const args = trimmed.slice("/budget_set".length).trim();
+        await this.handleBudgetCommand("set " + args, msg.channelType, msg.channelId);
+        this.lifecycle.transition("idle");
+        return;
+      }
+      if (trimmed.startsWith("/stream")) {
+        const sub = trimmed.slice("/stream".length).trim().toLowerCase();
+        if (sub === "off") {
+          this.telegramStreaming = false;
+        } else if (sub === "on") {
+          this.telegramStreaming = true;
+        } else {
+          this.telegramStreaming = !this.telegramStreaming;
+        }
+        const ch = this.channels.get(msg.channelType);
+        if (ch) await ch.send(
+          this.telegramStreaming ? "Telegram streaming enabled. Responses will appear progressively." : "Telegram streaming disabled. Responses will arrive as a single message.",
+          msg.channelId
+        );
+        this.lifecycle.transition("idle");
+        return;
+      }
+      if (await this.handleChatCommand(trimmed, msg.channelType, msg.channelId)) {
+        this.lifecycle.transition("idle");
+        return;
+      }
       if (this.tokenBudget.isOverBudget()) {
         const channel2 = this.channels.getChannelForMessage(msg);
         if (channel2 && msg.channelType !== "internal") {
@@ -815,7 +853,7 @@ You can override this:
       let usedProvider = null;
       let lastError = null;
       let streamedText = "";
-      const canStream = msg.channelType === "cli";
+      const canStream = msg.channelType === "cli" || msg.channelType === "telegram" && this.telegramStreaming;
       for (const provider of fallbackIterator) {
         try {
           logger.info({ provider: provider.name, model: provider.getModel(), steps: MAX_STEPS, stream: canStream }, "Generating agentic response");
@@ -835,7 +873,22 @@ You can override this:
                 }
               }
             });
-            const fullText = await channel.stream(streamResult.textStream, msg.channelId);
+            let fullText;
+            if (msg.channelType === "telegram") {
+              const tgChannel = this.channels.get("telegram");
+              if (tgChannel && "sendStreamToChat" in tgChannel) {
+                const chatId = msg.channelId.startsWith("telegram:") ? Number(msg.channelId.split(":")[1]) : Number(msg.channelId);
+                if (!isNaN(chatId)) {
+                  fullText = await tgChannel.sendStreamToChat(chatId, streamResult.textStream);
+                } else {
+                  fullText = await channel.stream(streamResult.textStream, msg.channelId);
+                }
+              } else {
+                fullText = await channel.stream(streamResult.textStream, msg.channelId);
+              }
+            } else {
+              fullText = await channel.stream(streamResult.textStream, msg.channelId);
+            }
             const [usage] = await Promise.all([
               streamResult.usage
             ]);
@@ -1099,6 +1152,79 @@ Or use /budget override, /budget reset, /budget set <number> anytime.`,
       await channel.send(`Unknown budget command "${action}". Available: /budget, /budget override, /budget reset, /budget set <number>, /budget status`, channelId);
     }
   }
+  async handleChatCommand(content, channelType, channelId) {
+    const cmd = content.toLowerCase().trim();
+    const channel = this.channels.get(channelType);
+    if (!channel) return false;
+    const ctx = this.capabilities.getChatCommandContext();
+    if (!ctx) return false;
+    if (cmd === "/help") {
+      await channel.send(ctx.manual(), channelId);
+      return true;
+    }
+    if (cmd === "/status") {
+      const config = ctx.config();
+      const budget = ctx.tokenBudget();
+      const lines = [
+        `**${config.identity.name}** \u2014 Status`,
+        `Owner: ${config.identity.owner || "(not set)"}`,
+        `Provider: ${config.providers.default}`,
+        `Telegram: ${config.channels.telegram.enabled ? "enabled" : "disabled"}`,
+        `Budget: ${budget.getStatusText()}`,
+        `Skills: ${ctx.skillNames().length > 0 ? ctx.skillNames().join(", ") : "none"}`
+      ];
+      await channel.send(lines.join("\n"), channelId);
+      return true;
+    }
+    if (cmd === "/tools") {
+      const tools = ctx.toolNames();
+      const grouped = [
+        `**${tools.length} tools loaded:**`,
+        "",
+        ...tools.sort().map((t) => `\u2022 \`${t}\``)
+      ];
+      await channel.send(grouped.join("\n"), channelId);
+      return true;
+    }
+    if (cmd === "/skills") {
+      const names = ctx.skillNames();
+      if (names.length === 0) {
+        await channel.send('No skills installed. Ask me to "install skill from <url>" to add one.', channelId);
+      } else {
+        const lines = [
+          `**${names.length} skill${names.length > 1 ? "s" : ""} installed:**`,
+          "",
+          ...names.map((n) => `\u2022 ${n}`)
+        ];
+        await channel.send(lines.join("\n"), channelId);
+      }
+      return true;
+    }
+    if (cmd === "/stream on") {
+      this.telegramStreaming = true;
+      await channel.send("Telegram streaming enabled. Responses will appear progressively.", channelId);
+      return true;
+    }
+    if (cmd === "/stream off") {
+      this.telegramStreaming = false;
+      await channel.send("Telegram streaming disabled. Responses will arrive as a single message.", channelId);
+      return true;
+    }
+    if (cmd === "/stream") {
+      this.telegramStreaming = !this.telegramStreaming;
+      await channel.send(
+        this.telegramStreaming ? "Telegram streaming enabled. Responses will appear progressively." : "Telegram streaming disabled. Responses will arrive as a single message.",
+        channelId
+      );
+      return true;
+    }
+    if (cmd === "/stream off") {
+      this.telegramStreaming = false;
+      await channel.send("Telegram streaming disabled. Responses will arrive as a single message.", channelId);
+      return true;
+    }
+    return false;
+  }
 };
 
 // src/core/scheduler.ts
@@ -1607,6 +1733,10 @@ var TelegramChannel = class extends BaseChannel {
   bot = null;
   ownerChatId = null;
   typingInterval = null;
+  chatCommandContext;
+  setChatCommandContext(ctx) {
+    this.chatCommandContext = ctx;
+  }
   async start() {
     const token = this.config.channels.telegram.botToken;
     if (!token) {
@@ -1637,12 +1767,33 @@ var TelegramChannel = class extends BaseChannel {
     });
     this.bot = bot;
     await bot.start({
-      onStart: (info) => {
+      onStart: async (info) => {
         logger.info({ bot: info.username }, "Telegram bot started \u2014 long polling active");
         this.ready = true;
+        await this.registerCommands();
       }
     });
   }
+  async registerCommands() {
+    if (!this.bot) return;
+    const commands = [
+      { command: "help", description: "Show capabilities and commands manual" },
+      { command: "status", description: "Show agent config, budget, and uptime" },
+      { command: "tools", description: "List all loaded tools" },
+      { command: "skills", description: "List installed skills" },
+      { command: "budget", description: "Show token budget status" },
+      { command: "budget_override", description: "Override budget for one request" },
+      { command: "budget_reset", description: "Reset token usage to zero" },
+      { command: "budget_set", description: "Set new daily token budget" },
+      { command: "stream", description: "Toggle text streaming on/off" }
+    ];
+    try {
+      await this.bot.api.setMyCommands(commands);
+      logger.info({ count: commands.length }, "Telegram bot commands registered");
+    } catch (err) {
+      logger.warn({ err: err.message }, "Failed to register Telegram commands (non-critical)");
+    }
+  }
   async stop() {
     this.bot?.stop();
     this.ready = false;
@@ -1739,23 +1890,64 @@ var TelegramChannel = class extends BaseChannel {
     }
   }
   async sendStreamToChat(chatId, textStream) {
-    if (!this.bot) return;
+    if (!this.bot) return "";
+    const STREAM_EDIT_INTERVAL = 1500;
+    const STREAM_MIN_LENGTH = 20;
     this.startTypingLoop(chatId);
     try {
       let full = "";
+      let messageId = null;
+      let lastEditTime = 0;
+      let lastEditLength = 0;
       for await (const chunk of textStream) {
         full += chunk;
+        const now = Date.now();
+        const timeSinceLastEdit = now - lastEditTime;
+        const charsSinceLastEdit = full.length - lastEditLength;
+        if (messageId === null && full.length >= STREAM_MIN_LENGTH) {
+          try {
+            const msg = await this.bot.api.sendMessage(chatId, this.escapeHtml(full) + " \u258C", { parse_mode: "HTML" });
+            messageId = msg.message_id;
+            lastEditTime = now;
+            lastEditLength = full.length;
+          } catch {
+            messageId = null;
+          }
+        } else if (messageId !== null && timeSinceLastEdit >= STREAM_EDIT_INTERVAL && charsSinceLastEdit >= 20) {
+          try {
+            await this.bot.api.editMessageText(chatId, messageId, this.escapeHtml(full) + " \u258C", { parse_mode: "HTML" });
+            lastEditTime = now;
+            lastEditLength = full.length;
+          } catch {
+          }
+        }
       }
-      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));
+      if (messageId !== null) {
+        const html = mdToTelegram(full);
+        try {
+          await this.bot.api.editMessageText(chatId, messageId, html, { parse_mode: "HTML" });
+        } catch {
+          try {
+            await this.bot.api.editMessageText(chatId, messageId, this.stripHtml(html));
+          } catch {
+          }
+        }
+      } else {
+        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));
+        }
       }
+      return full;
     } finally {
       this.stopTypingLoop();
     }
   }
+  escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
   splitMessage(text, maxLen) {
     if (text.length <= maxLen) return [text];
     const chunks = [];
@@ -3110,12 +3302,19 @@ var CapabilityRegistry = class {
   sendFileHandler;
   currentChannelId = "cli";
   currentChannelType = "cli";
+  chatCommandContext;
   constructor(skillLoader, scheduler, tokenBudget) {
     this.permissions = new PermissionManager();
     this.skillLoader = skillLoader;
     this.scheduler = scheduler;
     this.tokenBudget = tokenBudget;
   }
+  setChatCommandContext(ctx) {
+    this.chatCommandContext = ctx;
+  }
+  getChatCommandContext() {
+    return this.chatCommandContext;
+  }
   setChannelContext(channelId, channelType) {
     this.currentChannelId = channelId;
     this.currentChannelType = channelType;
@@ -3322,31 +3521,694 @@ Describe what this skill enables Mercury to do. When invoked via the use_skill t
   }
 };
 
+// src/utils/manual.ts
+import chalk3 from "chalk";
+function getManual() {
+  const sections = [];
+  sections.push("");
+  sections.push(chalk3.bold.cyan("  MERCURY \u2014 Capabilities & Commands"));
+  sections.push(chalk3.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  sections.push("");
+  sections.push(chalk3.bold.white("  Built-in Tools"));
+  sections.push(chalk3.dim("  Tools Mercury can use during conversations."));
+  sections.push("");
+  const tools = [
+    ["read_file", "Read file contents", "path (required)"],
+    ["write_file", "Write to an existing file", "path, content"],
+    ["create_file", "Create a new file (+ dirs)", "path, content"],
+    ["edit_file", "Replace specific text in a file", "path, old_string, new_string"],
+    ["list_dir", "List directory contents", "path"],
+    ["delete_file", "Delete a file", "path"],
+    ["run_command", "Execute a shell command", "command"],
+    ["approve_command", "Permanently approve a command type", 'command (e.g. "curl")'],
+    ["fetch_url", "Fetch a URL and return content", "url, format? (text/markdown)"],
+    ["git_status", "Show working tree status", "path?"],
+    ["git_diff", "Show file changes", "path?, staged?"],
+    ["git_log", "Show commit history", "count?, path?"],
+    ["git_add", "Stage files for commit", "paths (array)"],
+    ["git_commit", "Create a commit", "message"],
+    ["git_push", "Push to remote (needs approval)", "remote?, branch?"],
+    ["install_skill", "Install a skill from content or URL", "content? or url?"],
+    ["list_skills", "List installed skills", "\u2014"],
+    ["use_skill", "Invoke a skill by name", "name"],
+    ["schedule_task", "Schedule a recurring or delayed task", "cron? or delay_seconds, description, prompt? or skill_name?"],
+    ["list_scheduled_tasks", "List all scheduled tasks", "\u2014"],
+    ["cancel_scheduled_task", "Cancel a scheduled task", "id"],
+    ["budget_status", "Check token budget", "\u2014"]
+  ];
+  for (const [name, desc, params] of tools) {
+    sections.push(`  ${chalk3.cyan(name.padEnd(24))} ${desc}`);
+    sections.push(`  ${" ".repeat(24)} ${chalk3.dim(params)}`);
+  }
+  sections.push("");
+  sections.push(chalk3.bold.white("  CLI Commands"));
+  sections.push(chalk3.dim("  Run these from your terminal (no API calls consumed)."));
+  sections.push("");
+  const commands = [
+    ["mercury up", "Start persistently (install service + daemon)"],
+    ["mercury", "Start the agent (same as mercury start)"],
+    ["mercury start", "Start the agent in foreground"],
+    ["mercury start -d", "Start in background (daemon mode)"],
+    ["mercury restart", "Restart a background process"],
+    ["mercury stop", "Stop a background process"],
+    ["mercury logs", "Show recent daemon logs"],
+    ["mercury doctor", "Reconfigure settings (Enter keeps current)"],
+    ["mercury setup", "Re-run the setup wizard"],
+    ["mercury status", "Show config and daemon status"],
+    ["mercury help", "Show this manual"],
+    ["mercury service install", "Install as system service (auto-start)"],
+    ["mercury service uninstall", "Uninstall system service"],
+    ["mercury service status", "Show system service status"],
+    ["mercury --verbose", "Start with debug logging on stderr"]
+  ];
+  for (const [cmd, desc] of commands) {
+    sections.push(`  ${chalk3.white(cmd.padEnd(26))} ${desc}`);
+  }
+  sections.push("");
+  sections.push(chalk3.bold.white("  In-Chat Commands"));
+  sections.push(chalk3.dim("  Type these during a conversation (no API calls)."));
+  sections.push("");
+  const chat = [
+    ["/help", "Show this manual"],
+    ["/status", "Show config and budget info"],
+    ["/tools", "List currently loaded tools"],
+    ["/skills", "List installed skills"],
+    ["/stream", "Toggle text streaming on/off (Telegram)"],
+    ["/stream on", "Enable streaming (live text updates)"],
+    ["/stream off", "Disable streaming (single message)"]
+  ];
+  for (const [cmd, desc] of chat) {
+    sections.push(`  ${chalk3.white(cmd.padEnd(16))} ${desc}`);
+  }
+  sections.push("");
+  sections.push(chalk3.bold.white("  Permissions"));
+  sections.push("");
+  const perms = [
+    "Commands are blocked (never run), auto-approved, or need approval.",
+    'Say "always" when prompted to permanently approve a command type.',
+    "Edit ~/.mercury/permissions.yaml to customize manually.",
+    "File access is scoped \u2014 new paths need approval (y/n/always)."
+  ];
+  for (const p of perms) {
+    sections.push(`  ${chalk3.dim("\u2022")} ${p}`);
+  }
+  sections.push("");
+  sections.push(chalk3.bold.white("  Skills"));
+  sections.push("");
+  const skillInfo = [
+    "Skills live in ~/.mercury/skills/<name>/SKILL.md",
+    'Install: ask Mercury to "install skill from <url>" or paste content',
+    'Invoke: ask Mercury to "use skill <name>"',
+    'Schedule: "remind me daily at 9am to run daily-digest skill"'
+  ];
+  for (const s of skillInfo) {
+    sections.push(`  ${chalk3.dim("\u2022")} ${s}`);
+  }
+  sections.push("");
+  sections.push(chalk3.bold.white("  Scheduling"));
+  sections.push("");
+  const schedInfo = [
+    'Recurring: "every day at 9am remind me to\u2026"',
+    'One-shot: "remind me in 15 seconds to\u2026"',
+    "Tasks persist to ~/.mercury/schedules.yaml"
+  ];
+  for (const s of schedInfo) {
+    sections.push(`  ${chalk3.dim("\u2022")} ${s}`);
+  }
+  sections.push("");
+  sections.push(chalk3.bold.white("  Configuration"));
+  sections.push("");
+  const configInfo = [
+    ["~/.mercury/mercury.yaml", "Main config (providers, channels, budget)"],
+    ["~/.mercury/permissions.yaml", "Capabilities and approval rules"],
+    ["~/.mercury/soul/*.md", "Agent personality (soul, persona, taste, heartbeat)"],
+    ["~/.mercury/skills/", "Installed skills"],
+    ["~/.mercury/schedules.yaml", "Scheduled tasks"],
+    ["~/.mercury/token-usage.json", "Daily token usage tracking"],
+    ["~/.mercury/memory/", "Short-term, long-term, episodic memory"]
+  ];
+  for (const [path3, desc] of configInfo) {
+    sections.push(`  ${chalk3.dim(path3.padEnd(36))} ${desc}`);
+  }
+  sections.push("");
+  sections.push(chalk3.dim("  mercury.cosmicstack.org"));
+  sections.push("");
+  return sections.join("\n");
+}
+
+// src/cli/daemon.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync11, unlinkSync as unlinkSync3, mkdirSync as mkdirSync9, openSync } from "fs";
+import { join as join9 } from "path";
+import process2 from "process";
+import chalk4 from "chalk";
+var PID_FILE = "daemon.pid";
+var LOG_FILE = "daemon.log";
+function pidPath() {
+  return join9(getMercuryHome(), PID_FILE);
+}
+function logPath() {
+  return join9(getMercuryHome(), LOG_FILE);
+}
+function readPid() {
+  const path3 = pidPath();
+  if (!existsSync14(path3)) return null;
+  try {
+    const pid = parseInt(readFileSync11(path3, "utf-8").trim(), 10);
+    if (isNaN(pid)) return null;
+    return pid;
+  } catch {
+    return null;
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process2.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDaemonStatus() {
+  const pid = readPid();
+  if (!pid) return { running: false, pid: null, logPath: logPath() };
+  return { running: isProcessRunning(pid), pid, logPath: logPath() };
+}
+function startBackground() {
+  const status = getDaemonStatus();
+  if (status.running && status.pid) {
+    console.log(chalk4.yellow(`  Mercury is already running (PID: ${status.pid})`));
+    console.log(chalk4.dim(`  Use \`mercury stop\` to stop it first.`));
+    console.log("");
+    process2.exit(1);
+  }
+  if (status.pid && !status.running) {
+    try {
+      unlinkSync3(pidPath());
+    } catch {
+    }
+  }
+  const home = getMercuryHome();
+  if (!existsSync14(home)) {
+    mkdirSync9(home, { recursive: true });
+  }
+  const logFile = logPath();
+  const isWin = process2.platform === "win32";
+  const outFd = openSync(logFile, "a");
+  const child = spawn(process2.execPath, [process2.argv[1], "start", "--daemon"], {
+    detached: true,
+    stdio: ["ignore", outFd, outFd],
+    env: { ...process2.env },
+    windowsHide: isWin
+  });
+  child.unref();
+  writeFileSync11(pidPath(), String(child.pid));
+  console.log("");
+  console.log(chalk4.green(`  Mercury started in background (PID: ${child.pid})`));
+  console.log(chalk4.dim(`  Logs: ${logFile}`));
+  console.log(chalk4.dim(`  Use \`mercury stop\` to stop.`));
+  console.log(chalk4.dim(`  Use \`mercury logs\` to view logs.`));
+  console.log("");
+}
+function stopDaemon() {
+  const status = getDaemonStatus();
+  if (!status.pid) {
+    console.log(chalk4.yellow("  Mercury is not running as a daemon."));
+    console.log("");
+    process2.exit(0);
+  }
+  if (!status.running) {
+    console.log(chalk4.yellow(`  Stale PID file found (PID: ${status.pid} is not running). Cleaning up.`));
+    try {
+      unlinkSync3(pidPath());
+    } catch {
+    }
+    console.log("");
+    process2.exit(0);
+  }
+  try {
+    if (process2.platform === "win32") {
+      process2.kill(status.pid);
+    } else {
+      process2.kill(status.pid, "SIGTERM");
+    }
+    console.log(chalk4.green(`  Mercury stopped (PID: ${status.pid})`));
+  } catch {
+    console.log(chalk4.red(`  Failed to stop PID ${status.pid}. You may need to kill it manually.`));
+  }
+  try {
+    unlinkSync3(pidPath());
+  } catch {
+  }
+  console.log("");
+}
+function restartDaemon() {
+  const status = getDaemonStatus();
+  if (status.running && status.pid) {
+    console.log(chalk4.yellow(`  Stopping Mercury (PID: ${status.pid})...`));
+    try {
+      if (process2.platform === "win32") {
+        process2.kill(status.pid);
+      } else {
+        process2.kill(status.pid, "SIGTERM");
+      }
+    } catch {
+    }
+    try {
+      unlinkSync3(pidPath());
+    } catch {
+    }
+    console.log(chalk4.green("  Mercury stopped."));
+  } else if (status.pid) {
+    try {
+      unlinkSync3(pidPath());
+    } catch {
+    }
+  }
+  console.log(chalk4.yellow("  Starting Mercury..."));
+  startBackground();
+}
+function showLogs() {
+  const logFile = logPath();
+  if (!existsSync14(logFile)) {
+    console.log(chalk4.dim("  No daemon log file found."));
+    console.log("");
+    return;
+  }
+  const content = readFileSync11(logFile, "utf-8");
+  const lines = content.split("\n").slice(-100);
+  console.log(lines.join("\n"));
+}
+function tryAutoDaemonize() {
+  try {
+    const status = getDaemonStatus();
+    if (status.running && status.pid) {
+      return true;
+    }
+    if (status.pid && !status.running) {
+      try {
+        unlinkSync3(pidPath());
+      } catch {
+      }
+    }
+    const home = getMercuryHome();
+    if (!existsSync14(home)) {
+      mkdirSync9(home, { recursive: true });
+    }
+    const logFile = logPath();
+    const isWin = process2.platform === "win32";
+    const outFd = openSync(logFile, "a");
+    const child = spawn(process2.execPath, [process2.argv[1], "start", "--daemon"], {
+      detached: true,
+      stdio: ["ignore", outFd, outFd],
+      env: { ...process2.env },
+      windowsHide: isWin
+    });
+    child.unref();
+    if (!child.pid) {
+      return false;
+    }
+    writeFileSync11(pidPath(), String(child.pid));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/service.ts
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync12, unlinkSync as unlinkSync4 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir3 } from "os";
+import chalk5 from "chalk";
+import { execSync as execSync8 } from "child_process";
+var SERVICE_DESC = "Mercury \u2014 Soul-Driven AI Agent";
+var WIN_TASK_NAME = "MercuryAgent";
+function isServiceInstalled() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return existsSync15(join10(homedir3(), "Library", "LaunchAgents", "com.cosmicstack.mercury.plist"));
+  } else if (platform === "linux") {
+    return existsSync15(join10(homedir3(), ".config", "systemd", "user", "mercury.service"));
+  } else if (platform === "win32") {
+    try {
+      execSync8(`schtasks /query /tn "${WIN_TASK_NAME}"`, { stdio: "pipe", shell: "cmd.exe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function getNodeBinPath() {
+  return process.execPath;
+}
+function getDistPath() {
+  return join10(process.argv[1] || "/usr/local/bin/mercury", "..", "..", "lib", "node_modules", "@cosmicstack", "mercury-agent", "dist", "index.js");
+}
+function installService() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    installMac();
+  } else if (platform === "linux") {
+    installLinux();
+  } else if (platform === "win32") {
+    installWindows();
+  } else {
+    console.log(chalk5.red(`  Unsupported platform: ${platform}`));
+    process.exit(1);
+  }
+}
+function uninstallService() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    uninstallMac();
+  } else if (platform === "linux") {
+    uninstallLinux();
+  } else if (platform === "win32") {
+    uninstallWindows();
+  } else {
+    console.log(chalk5.red(`  Unsupported platform: ${platform}`));
+    process.exit(1);
+  }
+}
+function showServiceStatus() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    showMacStatus();
+  } else if (platform === "linux") {
+    showLinuxStatus();
+  } else if (platform === "win32") {
+    showWindowsStatus();
+  }
+}
+function installMac() {
+  const plistDir = join10(homedir3(), "Library", "LaunchAgents");
+  const plistPath = join10(plistDir, "com.cosmicstack.mercury.plist");
+  if (!existsSync15(plistDir)) {
+    mkdirSync10(plistDir, { recursive: true });
+  }
+  const nodeBin = getNodeBinPath();
+  const scriptPath = getDistPath();
+  const home = getMercuryHome();
+  const logPath2 = join10(home, "daemon.log");
+  const errPath = join10(home, "daemon-error.log");
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.cosmicstack.mercury</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodeBin}</string>
+    <string>${scriptPath}</string>
+    <string>start</string>
+    <string>--daemon</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${logPath2}</string>
+  <key>StandardErrorPath</key>
+  <string>${errPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}</string>
+    <key>HOME</key>
+    <string>${homedir3()}</string>
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${homedir3()}</string>
+</dict>
+</plist>`;
+  writeFileSync12(plistPath, plist, "utf-8");
+  try {
+    execSync8(`launchctl load ${plistPath}`, { stdio: "inherit" });
+  } catch {
+    console.log(chalk5.yellow("  launchctl load failed. Try running:"));
+    console.log(chalk5.dim(`    launchctl load ${plistPath}`));
+  }
+  console.log("");
+  console.log(chalk5.green("  Mercury service installed (macOS LaunchAgent)"));
+  console.log(chalk5.dim(`  Plist: ${plistPath}`));
+  console.log(chalk5.dim(`  Logs: ${logPath2}`));
+  console.log(chalk5.dim("  Auto-starts on login. Auto-restarts on crash."));
+  console.log("");
+  console.log(chalk5.dim("  Uninstall: mercury service uninstall"));
+  console.log("");
+}
+function uninstallMac() {
+  const plistPath = join10(homedir3(), "Library", "LaunchAgents", "com.cosmicstack.mercury.plist");
+  if (!existsSync15(plistPath)) {
+    console.log(chalk5.yellow("  Mercury service is not installed."));
+    console.log("");
+    process.exit(0);
+  }
+  try {
+    execSync8(`launchctl unload ${plistPath}`, { stdio: "inherit" });
+  } catch {
+  }
+  try {
+    unlinkSync4(plistPath);
+  } catch {
+    console.log(chalk5.yellow("  Failed to remove plist file. Remove manually:"));
+    console.log(chalk5.dim(`    rm ${plistPath}`));
+  }
+  console.log("");
+  console.log(chalk5.green("  Mercury service uninstalled"));
+  console.log("");
+}
+function showMacStatus() {
+  const plistPath = join10(homedir3(), "Library", "LaunchAgents", "com.cosmicstack.mercury.plist");
+  if (!existsSync15(plistPath)) {
+    console.log(chalk5.yellow("  Mercury service is not installed."));
+    console.log(chalk5.dim("  Run `mercury service install` to set it up."));
+    console.log("");
+    return;
+  }
+  try {
+    const output = execSync8("launchctl list | grep com.cosmicstack.mercury", { encoding: "utf-8" }).trim();
+    console.log(`  ${chalk5.green("Service installed and loaded")}`);
+    console.log(chalk5.dim(`  ${output}`));
+  } catch {
+    console.log(`  ${chalk5.yellow("Service installed but not loaded")}`);
+    console.log(chalk5.dim(`  Plist: ${plistPath}`));
+  }
+  console.log("");
+}
+function installLinux() {
+  const systemdDir = join10(homedir3(), ".config", "systemd", "user");
+  if (!existsSync15(systemdDir)) {
+    mkdirSync10(systemdDir, { recursive: true });
+  }
+  const servicePath = join10(systemdDir, "mercury.service");
+  const nodeBin = getNodeBinPath();
+  const scriptPath = getDistPath();
+  const home = getMercuryHome();
+  const service = `[Unit]
+Description=${SERVICE_DESC}
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodeBin} ${scriptPath} start --daemon
+Restart=on-failure
+RestartSec=5
+Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
+Environment=HOME=${homedir3()}
+WorkingDirectory=${homedir3()}
+StandardOutput=append:${join10(home, "daemon.log")}
+StandardError=append:${join10(home, "daemon-error.log")}
+
+[Install]
+WantedBy=default.target`;
+  writeFileSync12(servicePath, service, "utf-8");
+  try {
+    execSync8("systemctl --user daemon-reload", { stdio: "inherit" });
+    execSync8("systemctl --user enable mercury.service", { stdio: "inherit" });
+    execSync8("systemctl --user start mercury.service", { stdio: "inherit" });
+  } catch (err) {
+    console.log(chalk5.yellow("  systemd commands failed. Try running manually:"));
+    console.log(chalk5.dim("    systemctl --user daemon-reload"));
+    console.log(chalk5.dim("    systemctl --user enable mercury.service"));
+    console.log(chalk5.dim("    systemctl --user start mercury.service"));
+  }
+  try {
+    execSync8(`loginctl enable-linger ${process.env.USER || ""}`, { stdio: "inherit" });
+  } catch {
+    console.log(chalk5.yellow("  Enable linger failed (needed for boot-without-login). Try:"));
+    console.log(chalk5.dim(`    sudo loginctl enable-linger ${process.env.USER || "$USER"}`));
+  }
+  console.log("");
+  console.log(chalk5.green("  Mercury service installed (systemd --user)"));
+  console.log(chalk5.dim(`  Service: ${servicePath}`));
+  console.log(chalk5.dim(`  Logs: ${join10(home, "daemon.log")}`));
+  console.log(chalk5.dim("  Auto-starts on login. Auto-restarts on crash (5s delay)."));
+  console.log("");
+  console.log(chalk5.dim("  Uninstall: mercury service uninstall"));
+  console.log("");
+}
+function uninstallLinux() {
+  const servicePath = join10(homedir3(), ".config", "systemd", "user", "mercury.service");
+  if (!existsSync15(servicePath)) {
+    console.log(chalk5.yellow("  Mercury service is not installed."));
+    console.log("");
+    process.exit(0);
+  }
+  try {
+    execSync8("systemctl --user stop mercury.service", { stdio: "inherit" });
+    execSync8("systemctl --user disable mercury.service", { stdio: "inherit" });
+  } catch {
+  }
+  try {
+    unlinkSync4(servicePath);
+  } catch {
+    console.log(chalk5.yellow("  Failed to remove service file. Remove manually:"));
+    console.log(chalk5.dim(`    rm ${servicePath}`));
+  }
+  try {
+    execSync8("systemctl --user daemon-reload", { stdio: "inherit" });
+  } catch {
+  }
+  console.log("");
+  console.log(chalk5.green("  Mercury service uninstalled"));
+  console.log("");
+}
+function showLinuxStatus() {
+  const servicePath = join10(homedir3(), ".config", "systemd", "user", "mercury.service");
+  if (!existsSync15(servicePath)) {
+    console.log(chalk5.yellow("  Mercury service is not installed."));
+    console.log(chalk5.dim("  Run `mercury service install` to set it up."));
+    console.log("");
+    return;
+  }
+  try {
+    const output = execSync8("systemctl --user status mercury.service", { encoding: "utf-8" }).trim();
+    console.log(output);
+  } catch (err) {
+    console.log(chalk5.yellow("  Could not get service status:"));
+    console.log(chalk5.dim(`  ${err.message || err}`));
+  }
+  console.log("");
+}
+function installWindows() {
+  const nodeBin = getNodeBinPath();
+  const scriptPath = getDistPath();
+  const home = getMercuryHome();
+  const logPath2 = join10(home, "daemon.log");
+  const cmd = `"${nodeBin}" "${scriptPath}" start --daemon`;
+  try {
+    execSync8(
+      `schtasks /create /tn "${WIN_TASK_NAME}" /tr "${cmd}" /sc onlogon /rl limited /f`,
+      { stdio: "inherit", shell: "cmd.exe" }
+    );
+  } catch {
+    console.log(chalk5.yellow("  schtasks create failed. Try running from an Administrator cmd:"));
+    console.log(chalk5.dim(`    schtasks /create /tn "${WIN_TASK_NAME}" /tr "${cmd}" /sc onlogon /rl limited /f`));
+  }
+  try {
+    execSync8(`schtasks /run /tn "${WIN_TASK_NAME}"`, { stdio: "inherit", shell: "cmd.exe" });
+  } catch {
+    console.log(chalk5.yellow("  Task created but failed to start immediately. It will start on next login."));
+  }
+  console.log("");
+  console.log(chalk5.green("  Mercury service installed (Windows Task Scheduler)"));
+  console.log(chalk5.dim(`  Task: ${WIN_TASK_NAME}`));
+  console.log(chalk5.dim(`  Trigger: on logon`));
+  console.log(chalk5.dim(`  Logs: ${logPath2}`));
+  console.log(chalk5.dim("  Auto-starts on login. Use --daemon flag for crash recovery."));
+  console.log("");
+  console.log(chalk5.dim("  Uninstall: mercury service uninstall"));
+  console.log("");
+}
+function uninstallWindows() {
+  try {
+    execSync8(`schtasks /delete /tn "${WIN_TASK_NAME}" /f`, { stdio: "inherit", shell: "cmd.exe" });
+    console.log("");
+    console.log(chalk5.green("  Mercury service uninstalled"));
+    console.log("");
+  } catch {
+    console.log(chalk5.yellow("  Task not found or failed to delete. Remove manually:"));
+    console.log(chalk5.dim(`    schtasks /delete /tn "${WIN_TASK_NAME}" /f`));
+    console.log("");
+  }
+}
+function showWindowsStatus() {
+  try {
+    const output = execSync8(`schtasks /query /tn "${WIN_TASK_NAME}" /fo list`, {
+      encoding: "utf-8",
+      shell: "cmd.exe"
+    }).trim();
+    console.log(output);
+    console.log("");
+  } catch {
+    console.log(chalk5.yellow("  Mercury service is not installed."));
+    console.log(chalk5.dim("  Run `mercury service install` to set it up."));
+    console.log("");
+  }
+}
+
+// src/cli/watchdog.ts
+var MAX_RESTARTS = 10;
+var RESTART_WINDOW_MS = 6e4;
+var BASE_DELAY_MS = 1e3;
+async function runWithWatchdog(agentFn) {
+  const restarts = [];
+  async function attempt() {
+    try {
+      await agentFn();
+    } catch (err) {
+      const now = Date.now();
+      restarts.push(now);
+      const recentRestarts = restarts.filter((t) => now - t < RESTART_WINDOW_MS);
+      const restartCount = recentRestarts.length;
+      if (restartCount >= MAX_RESTARTS) {
+        logger.error({ restartCount }, "Max restarts exceeded within 60s. Exiting.");
+        process.exit(1);
+      }
+      const delay = BASE_DELAY_MS * Math.pow(1.25, restartCount);
+      logger.warn({ err, restartCount, delay }, "Crash detected. Restarting with backoff...");
+      await sleep(delay);
+      await attempt();
+    }
+  }
+  await attempt();
+}
+function sleep(ms) {
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
+}
+
 // src/index.ts
 function hr() {
-  console.log(chalk3.dim("\u2500".repeat(50)));
+  console.log(chalk6.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}`));
+    if (line.trim()) console.log(chalk6.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(chalk6.white("  an AI agent for personal tasks"));
+  console.log(chalk6.dim("  v0.2.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}`));
+    if (line.trim()) console.log(chalk6.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(chalk6.dim("  an AI agent for personal tasks"));
+  console.log(chalk6.cyan("  by Cosmic Stack"));
+  console.log(chalk6.dim("  mercury.cosmicstack.org"));
   console.log("");
 }
 async function ask(prompt) {
@@ -3358,81 +4220,189 @@ async function ask(prompt) {
     });
   });
 }
-async function onboarding() {
-  splashScreen();
-  console.log(chalk3.yellow("  First run detected \u2014 let's set you up."));
+function maskKey(key) {
+  if (!key) return "";
+  if (key.length <= 8) return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+  return key.slice(0, 4) + "\u2022\u2022\u2022\u2022" + key.slice(-4);
+}
+async function configure(existingConfig) {
+  const isReconfig = !!existingConfig;
+  const config = existingConfig ?? loadConfig();
+  if (isReconfig) {
+    banner();
+    console.log(chalk6.yellow("  Reconfiguring Mercury \u2014 press Enter to keep current value."));
+  } else {
+    splashScreen();
+    console.log(chalk6.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);
+  console.log(chalk6.bold.white("  Identity"));
+  console.log("");
+  if (isReconfig) {
+    const ownerName = await ask(chalk6.white(`  Your name [${config.identity.owner}]: `));
+    if (ownerName) config.identity.owner = ownerName;
+    const agentName = await ask(chalk6.white(`  Agent name [${config.identity.name}]: `));
+    if (agentName) config.identity.name = agentName;
+  } else {
+    const ownerName = await ask(chalk6.white("  Your name: "));
+    if (!ownerName) {
+      console.log(chalk6.red("  Name is required."));
+      process.exit(1);
+    }
+    config.identity.owner = ownerName;
+    const agentName = await ask(chalk6.white(`  Agent name [${config.identity.name}]: `));
+    if (agentName) config.identity.name = agentName;
   }
-  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";
+  config.identity.creator = 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(chalk6.bold.white("  LLM Providers"));
+  if (isReconfig) {
+    console.log(chalk6.dim("  Current keys shown masked. Enter new value to change, Enter to keep."));
+  } else {
+    console.log(chalk6.dim("  At least one API key is required."));
+  }
   console.log("");
-  const deepseekKey = await ask(chalk3.white("  DeepSeek API key: "));
+  const dsMask = isReconfig && config.providers.deepseek.apiKey ? ` [${maskKey(config.providers.deepseek.apiKey)}]` : "";
+  const deepseekKey = await ask(chalk6.white(`  DeepSeek API key${dsMask}: `));
   if (deepseekKey) {
     config.providers.deepseek.apiKey = deepseekKey;
-    config.providers.default = "deepseek";
   }
-  const openaiKey = await ask(chalk3.white("  OpenAI API key (Enter to skip): "));
+  const oaiMask = isReconfig && config.providers.openai.apiKey ? ` [${maskKey(config.providers.openai.apiKey)}]` : " (Enter to skip)";
+  const openaiKey = await ask(chalk6.white(`  OpenAI API key${oaiMask}: `));
   if (openaiKey) config.providers.openai.apiKey = openaiKey;
-  const anthropicKey = await ask(chalk3.white("  Anthropic API key (Enter to skip): "));
+  const antMask = isReconfig && config.providers.anthropic.apiKey ? ` [${maskKey(config.providers.anthropic.apiKey)}]` : " (Enter to skip)";
+  const anthropicKey = await ask(chalk6.white(`  Anthropic API key${antMask}: `));
   if (anthropicKey) config.providers.anthropic.apiKey = anthropicKey;
-  if (!deepseekKey && !openaiKey && !anthropicKey) {
-    console.log(chalk3.red("\n  At least one LLM API key is required."));
+  const hasKey = config.providers.deepseek.apiKey || config.providers.openai.apiKey || config.providers.anthropic.apiKey;
+  if (!hasKey) {
+    console.log(chalk6.red("\n  At least one LLM API key is required."));
     process.exit(1);
   }
+  const availableProviders = [];
+  if (config.providers.deepseek.apiKey) availableProviders.push("deepseek");
+  if (config.providers.openai.apiKey) availableProviders.push("openai");
+  if (config.providers.anthropic.apiKey) availableProviders.push("anthropic");
+  if (isReconfig && availableProviders.length > 1) {
+    console.log("");
+    console.log(chalk6.bold.white("  Default Provider"));
+    console.log(chalk6.dim("  Select the default LLM provider (the one used first)."));
+    console.log("");
+    for (let i = 0; i < availableProviders.length; i++) {
+      const marker = availableProviders[i] === config.providers.default ? " (current)" : "";
+      console.log(chalk6.white(`    ${i + 1}. ${availableProviders[i]}${marker}`));
+    }
+    console.log("");
+    const choice = await ask(chalk6.white(`  Choose [1-${availableProviders.length}] [Enter to keep ${config.providers.default}]: `));
+    const num = parseInt(choice, 10);
+    if (num >= 1 && num <= availableProviders.length) {
+      config.providers.default = availableProviders[num - 1];
+    }
+  } else if (!isReconfig) {
+    config.providers.default = availableProviders[0];
+    console.log(chalk6.dim(`  Default provider set to ${config.providers.default}`));
+  }
   hr();
   console.log("");
-  console.log(chalk3.white("  Telegram (optional)"));
-  console.log(chalk3.dim("  Leave empty to skip. You can add it later."));
+  console.log(chalk6.bold.white("  Telegram (optional)"));
+  if (isReconfig) {
+    console.log(chalk6.dim('  Leave empty to keep current value. Enter "none" to disable.'));
+  } else {
+    console.log(chalk6.dim("  Leave empty to skip. You can add it later."));
+  }
   console.log("");
-  const telegramToken = await ask(chalk3.white("  Telegram Bot Token: "));
-  if (telegramToken) {
+  const tgMask = isReconfig && config.channels.telegram.botToken ? ` [${maskKey(config.channels.telegram.botToken)}]` : "";
+  const telegramToken = await ask(chalk6.white(`  Telegram Bot Token${tgMask}: `));
+  if (isReconfig && telegramToken.toLowerCase() === "none") {
+    config.channels.telegram.enabled = false;
+    config.channels.telegram.botToken = "";
+  } else if (telegramToken) {
     config.channels.telegram.botToken = telegramToken;
     config.channels.telegram.enabled = true;
   }
   hr();
+  console.log("");
+  console.log(chalk6.bold.white("  Token Budget"));
+  console.log("");
+  const budgetPrompt = isReconfig ? chalk6.white(`  Daily token budget [${config.tokens.dailyBudget.toLocaleString()}]: `) : chalk6.white(`  Daily token budget [${config.tokens.dailyBudget.toLocaleString()}]: `);
+  const budgetStr = await ask(budgetPrompt);
+  if (budgetStr) {
+    const budget = parseInt(budgetStr.replace(/,/g, ""), 10);
+    if (!isNaN(budget) && budget > 0) {
+      config.tokens.dailyBudget = budget;
+    }
+  }
+  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(chalk6.green(`  \u2713 Config saved to ${home}/mercury.yaml`));
+  console.log(chalk6.green(`  \u2713 Soul files seeded in ${home}/soul/`));
+  console.log(chalk6.green(`  \u2713 Memory stored in ${home}/memory/`));
+  console.log(chalk6.green(`  \u2713 Permissions seeded in ${home}/permissions.yaml`));
+  console.log(chalk6.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(chalk6.cyan(`  ${config.identity.name} is ready. Run \`mercury start\` to chat.`));
+  console.log(chalk6.dim("  mercury.cosmicstack.org"));
   console.log("");
 }
-async function runAgent() {
+function autoDaemonize() {
+  const daemon = getDaemonStatus();
+  if (daemon.running) {
+    return;
+  }
+  console.log(chalk6.dim("  Setting up background mode..."));
+  try {
+    if (!isServiceInstalled()) {
+      installService();
+    }
+  } catch {
+    console.log(chalk6.dim("  Service install skipped (can run `mercury service install` later)."));
+  }
+  const ok = tryAutoDaemonize();
+  if (ok) {
+    const status = getDaemonStatus();
+    console.log(chalk6.green(`  \u2713 Mercury is running in background (PID: ${status.pid})`));
+    console.log(chalk6.green("  \u2713 Auto-starts on login. Auto-restarts on crash."));
+    console.log(chalk6.dim("  Use `mercury stop` to stop. `mercury restart` to restart."));
+  } else {
+    console.log(chalk6.dim("  Background mode not available. Run `mercury up` to set it up."));
+  }
+  console.log("");
+}
+async function runAgent(isDaemon = false) {
   let config = loadConfig();
   config = ensureCreatorField(config);
   const name = config.identity.name;
-  banner();
-  console.log(chalk3.white(`  ${name} is waking up...`));
-  console.log("");
+  if (!isDaemon) {
+    banner();
+    console.log(chalk6.white(`  ${name} is waking up...`));
+    console.log("");
+  } else {
+    logger.info(`${name} is waking up (daemon mode)...`);
+  }
   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."));
+    if (isDaemon) {
+      logger.error("No LLM providers available. Run `mercury doctor` to configure API keys.");
+      return;
+    }
+    console.log(chalk6.red("  No LLM providers available. Run `mercury doctor` to configure API keys."));
     process.exit(1);
   }
   const available = providers.listAvailable();
-  console.log(chalk3.dim(`  Providers: ${available.join(", ")}`));
+  if (!isDaemon) {
+    console.log(chalk6.dim(`  Providers: ${available.join(", ")}`));
+  } else {
+    logger.info({ providers: available }, "Providers loaded");
+  }
   const skillLoader = new SkillLoader();
   const skills = skillLoader.discover();
-  console.log(chalk3.dim(`  Skills: ${skills.length > 0 ? skills.map((s) => s.name).join(", ") : "none installed"}`));
+  if (!isDaemon) {
+    console.log(chalk6.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);
@@ -3440,6 +4410,13 @@ async function runAgent() {
   const episodic = new EpisodicMemory(config);
   const channels = new ChannelRegistry(config);
   const capabilities = new CapabilityRegistry(skillLoader, scheduler, tokenBudget);
+  capabilities.setChatCommandContext({
+    toolNames: () => capabilities.getToolNames(),
+    skillNames: () => skills.map((s) => s.name),
+    config: () => config,
+    tokenBudget: () => tokenBudget,
+    manual: () => getManual()
+  });
   capabilities.setSendFileHandler(async (filePath) => {
     const msg = channels.getActiveChannels().includes("telegram") ? channels.get("telegram") : channels.get("cli");
     if (msg) {
@@ -3469,21 +4446,29 @@ async function runAgent() {
   }
   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}`));
+  if (!isDaemon) {
+    console.log(chalk6.dim(`  Channels: ${activeCh.join(", ")}`));
+    console.log(chalk6.dim(`  Tools: ${toolNames.join(", ")}`));
+    console.log(chalk6.dim(`  Permissions: ${getMercuryHome()}/permissions.yaml`));
+    console.log(chalk6.dim(`  Schedules: ${getMercuryHome()}/schedules.yaml`));
+    if (config.identity.creator) {
+      console.log(chalk6.dim(`  Creator: ${config.identity.creator}`));
+    }
+    hr();
+    console.log("");
+    console.log(chalk6.green(`  ${name} is live. Type a message and press Enter.`));
+    console.log(chalk6.dim("  Ctrl+C to exit \xB7 /help for commands"));
+    console.log("");
+  } else {
+    logger.info({ channels: activeCh, tools: toolNames }, "Mercury is live (daemon mode)");
   }
-  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...`));
+    if (!isDaemon) {
+      console.log("");
+      console.log(chalk6.dim(`  ${name} is shutting down...`));
+    } else {
+      logger.info("Mercury is shutting down (daemon mode)");
+    }
     await agent.shutdown();
     process.exit(0);
   };
@@ -3491,41 +4476,105 @@ async function runAgent() {
   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 () => {
+program.name("mercury").description("Mercury \u2014 Soul-driven AI agent with permission-hardened tools, token budgets, and multi-channel access.").version("0.2.0").option("-v, --verbose", "Show debug logs").action(async () => {
   if (!isSetupComplete()) {
-    await onboarding();
+    await configure();
+    autoDaemonize();
     return;
   }
   await runAgent();
 });
-program.command("start").description("Start Mercury agent").option("-v, --verbose", "Show debug logs").action(async () => {
+program.command("start").description("Start Mercury agent").option("-v, --verbose", "Show debug logs").option("-d, --detached", "Run in background (daemon mode)").option("--daemon", "Internal flag for daemon child process").action(async (opts) => {
+  if (opts.daemon) {
+    await runWithWatchdog(() => runAgent(true));
+    return;
+  }
+  if (opts.detached) {
+    startBackground();
+    return;
+  }
   if (!isSetupComplete()) {
-    await onboarding();
+    await configure();
     return;
   }
   await runAgent();
 });
-program.command("setup").description("Re-run the setup wizard").action(async () => {
-  await onboarding();
+program.command("stop").description("Stop a background Mercury process").action(() => {
+  stopDaemon();
+});
+program.command("restart").description("Restart a background Mercury process").action(() => {
+  restartDaemon();
+});
+program.command("up").description("Ensure Mercury is running persistently \u2014 installs service if needed, starts daemon").action(async () => {
+  if (!isSetupComplete()) {
+    await configure();
+  }
+  const daemon = getDaemonStatus();
+  if (daemon.running && daemon.pid) {
+    console.log("");
+    console.log(chalk6.green(`  Mercury is already running (PID: ${daemon.pid})`));
+    console.log(chalk6.dim(`  Logs: ${daemon.logPath}`));
+    console.log("");
+    return;
+  }
+  if (!isServiceInstalled()) {
+    console.log("");
+    console.log(chalk6.cyan("  Installing Mercury as a system service..."));
+    installService();
+  }
+  console.log(chalk6.cyan("  Starting Mercury in background..."));
+  startBackground();
+});
+program.command("logs").description("Show recent daemon logs").action(() => {
+  showLogs();
+});
+program.command("setup").description("Re-run the setup wizard (reconfigure)").action(async () => {
+  if (isSetupComplete()) {
+    await configure(loadConfig());
+  } else {
+    await configure();
+  }
+});
+program.command("doctor").description("Reconfigure Mercury \u2014 change keys, name, settings (Enter to keep current)").action(async () => {
+  if (isSetupComplete()) {
+    await configure(loadConfig());
+  } else {
+    await configure();
+  }
 });
-program.command("status").description("Show current configuration").action(() => {
+program.command("status").description("Show current configuration and daemon status").action(() => {
   const config = loadConfig();
   const home = getMercuryHome();
   const skillLoader = new SkillLoader();
   const skills = skillLoader.discover();
+  const daemon = getDaemonStatus();
   banner();
-  console.log(`  Name:     ${chalk3.cyan(config.identity.name)}`);
-  console.log(`  Owner:    ${chalk3.white(config.identity.owner || "(not set)")}`);
+  console.log(`  Name:     ${chalk6.cyan(config.identity.name)}`);
+  console.log(`  Owner:    ${chalk6.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(`  Creator:  ${chalk6.white(config.identity.creator)}`);
+  }
+  console.log(`  Provider: ${chalk6.white(config.providers.default)}`);
+  console.log(`  Telegram: ${config.channels.telegram.enabled ? chalk6.green("enabled") : chalk6.dim("disabled")}`);
+  console.log(`  Skills:   ${skills.length > 0 ? chalk6.green(skills.map((s) => s.name).join(", ")) : chalk6.dim("none")}`);
+  console.log(`  Budget:   ${chalk6.white(config.tokens.dailyBudget.toLocaleString())} tokens/day`);
+  console.log(`  Setup:    ${isSetupComplete() ? chalk6.green("complete") : chalk6.red("not done")}`);
+  console.log(`  Daemon:   ${daemon.running ? chalk6.green(`running (PID: ${daemon.pid})`) : chalk6.dim("not running")}`);
+  console.log(`  Home:     ${chalk6.dim(home)}`);
   console.log("");
 });
+program.command("help").description("Show capabilities and commands manual").action(() => {
+  console.log(getManual());
+});
+var serviceCmd = program.command("service").description("Manage Mercury as a system service (auto-start, crash recovery)");
+serviceCmd.command("install").description("Install Mercury as a system service (auto-start on boot)").action(() => {
+  installService();
+});
+serviceCmd.command("uninstall").description("Uninstall the system service").action(() => {
+  uninstallService();
+});
+serviceCmd.command("status").description("Show system service status").action(() => {
+  showServiceStatus();
+});
 program.parse();
 //# sourceMappingURL=index.js.map