augure 0.4.2 → 0.5.1

package/dist/bin.js

@@ -50,9 +50,12 @@ var AppConfigSchema = z.object({
     heartbeatInterval: z.string().min(1),
     jobs: z.array(z.object({
       id: z.string().min(1),
-      cron: z.string().min(1),
+      cron: z.string().min(1).optional(),
+      runAt: z.string().min(1).optional(),
       prompt: z.string().min(1),
       channel: z.string().min(1)
+    }).refine((j) => j.cron || j.runAt, {
+      message: "Job must have either cron or runAt"
     }))
   }),
   sandbox: z.object({
@@ -150,19 +153,33 @@ async function loadConfig(path) {
   return AppConfigSchema.parse(parsed);
 }
 
+// ../types/dist/logger.js
+var noop = () => {
+};
+var noopLogger = {
+  debug: noop,
+  info: noop,
+  warn: noop,
+  error: noop,
+  child: () => noopLogger
+};
+
 // ../core/dist/llm.js
 var OpenRouterClient = class {
   apiKey;
   model;
   maxTokens;
   baseUrl;
+  log;
   constructor(config) {
     this.apiKey = config.apiKey;
     this.model = config.model;
     this.maxTokens = config.maxTokens;
     this.baseUrl = config.baseUrl ?? "https://openrouter.ai/api/v1";
+    this.log = config.logger ?? noopLogger;
   }
   async chat(messages, tools) {
+    this.log.debug(`Request: model=${this.model} messages=${messages.length} tools=${tools?.length ?? 0}`);
     const response = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
@@ -196,6 +213,7 @@ var OpenRouterClient = class {
     }
     const data = await response.json();
     const choice = data.choices[0];
+    this.log.debug(`Response: ${response.status} ${data.usage.prompt_tokens}+${data.usage.completion_tokens} tokens`);
     return {
       content: choice.message.content ?? "",
       toolCalls: (choice.message.tool_calls ?? []).map((tc) => {
@@ -203,7 +221,7 @@ var OpenRouterClient = class {
         try {
           args = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
         } catch {
-          console.error(`[augure] Failed to parse tool call arguments for ${tc.function.name}:`, tc.function.arguments);
+          this.log.warn(`Failed to parse tool call arguments for ${tc.function.name}`);
         }
         return { id: tc.id, name: tc.function.name, arguments: args };
       }),
@@ -219,6 +237,19 @@ var OpenRouterClient = class {
 function assembleContext(input) {
   const { systemPrompt, memoryContent, conversationHistory, persona } = input;
   let system = systemPrompt;
+  const now = /* @__PURE__ */ new Date();
+  const humanDate = new Intl.DateTimeFormat("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZoneName: "short"
+  }).format(now);
+  system += `
+
+Current date and time: ${now.toISOString()} (${humanDate})`;
   if (persona) {
     system += `
 
@@ -246,13 +277,15 @@ function summarize(text, maxLen = 200) {
 }
 var FileAuditLogger = class {
   basePath;
+  logger;
   pendingWrite = Promise.resolve();
   initialized = false;
-  constructor(basePath) {
+  constructor(basePath, logger) {
     this.basePath = basePath;
+    this.logger = logger ?? noopLogger;
   }
   log(entry) {
-    this.pendingWrite = this.pendingWrite.then(() => this.writeEntry(entry)).catch((err2) => console.error("[augure] Audit write error:", err2));
+    this.pendingWrite = this.pendingWrite.then(() => this.writeEntry(entry)).catch((err2) => this.logger.error("Audit write error:", err2));
   }
   async close() {
     await this.pendingWrite;
@@ -278,10 +311,12 @@ var NullAuditLogger = class {
 // ../core/dist/agent.js
 var Agent = class {
   config;
+  log;
   conversations = /* @__PURE__ */ new Map();
   state = "running";
   constructor(config) {
     this.config = config;
+    this.log = config.logger ?? noopLogger;
   }
   getState() {
     return this.state;
@@ -321,12 +356,14 @@ var Agent = class {
         conversationHistory: history,
         persona: this.config.persona
       });
+      this.log.debug(`LLM call #${loopCount + 1} (${messages.length} messages)`);
       const response = await this.config.llm.chat(messages, toolSchemas);
       if (response.toolCalls.length === 0) {
         history.push({
           role: "assistant",
           content: response.content
         });
+        this.log.debug(`Response: ${response.usage.inputTokens}+${response.usage.outputTokens} tokens, ${Date.now() - start}ms`);
         if (this.config.audit) {
           this.config.audit.log({
             ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -344,7 +381,7 @@ var Agent = class {
           });
         }
         if (this.config.ingester) {
-          this.config.ingester.ingest(history).catch((err2) => console.error("[augure] Ingestion error:", err2));
+          this.config.ingester.ingest(history).catch((err2) => this.log.error("Ingestion error:", err2));
         }
         return response.content;
       }
@@ -355,7 +392,9 @@ var Agent = class {
       });
       for (const toolCall of response.toolCalls) {
         const toolStart = Date.now();
+        this.log.debug(`Tool: ${toolCall.name}`);
         const result = await this.config.tools.execute(toolCall.name, toolCall.arguments);
+        this.log.debug(`Tool ${toolCall.name}: ${result.success ? "ok" : "fail"} (${Date.now() - toolStart}ms)`);
         history.push({
           role: "tool",
           content: result.output,
@@ -563,6 +602,56 @@ var ContextGuard = class {
   }
 };
 
+// ../core/dist/logger.js
+import { styleText } from "util";
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+function tag(level) {
+  switch (level) {
+    case "debug":
+      return styleText("magenta", "DBG");
+    case "info":
+      return styleText("cyan", "INF");
+    case "warn":
+      return styleText("yellow", "WRN");
+    case "error":
+      return styleText("red", "ERR");
+  }
+}
+function createLogger(opts = {}) {
+  const min = LEVELS[opts.level ?? "info"];
+  const scope = opts.scope;
+  function emit(level, msg, args) {
+    if (LEVELS[level] < min)
+      return;
+    const ts = styleText("dim", (/* @__PURE__ */ new Date()).toISOString().slice(11, 23));
+    const lvl = tag(level);
+    const sc = scope ? ` ${styleText("dim", scope)}` : "";
+    const prefix2 = `${styleText("yellow", "\u25B2")} ${ts} ${lvl}${sc}`;
+    const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+    if (args.length > 0) {
+      fn(prefix2, msg, ...args);
+    } else {
+      fn(prefix2, msg);
+    }
+  }
+  return {
+    debug: (msg, ...args) => emit("debug", msg, args),
+    info: (msg, ...args) => emit("info", msg, args),
+    warn: (msg, ...args) => emit("warn", msg, args),
+    error: (msg, ...args) => emit("error", msg, args),
+    child: (childScope) => createLogger({
+      level: opts.level,
+      scope: scope ? `${scope}:${childScope}` : childScope
+    })
+  };
+}
+
 // ../channels/dist/telegram/telegram.js
 import { Bot } from "grammy";
 
@@ -582,62 +671,6 @@ function createOutgoingPipeline(middlewares, send) {
   };
 }
 
-// ../channels/dist/middleware/escape-markdown.js
-var SPECIAL_CHARS = /* @__PURE__ */ new Set([".", "!", ">", "#", "+", "-", "=", "|", "{", "}", "~"]);
-function escapeMarkdownV2(text) {
-  if (!text)
-    return "";
-  const parts = [];
-  let i = 0;
-  while (i < text.length) {
-    if (text.startsWith("```", i)) {
-      const endIdx = text.indexOf("```", i + 3);
-      if (endIdx !== -1) {
-        parts.push(text.slice(i, endIdx + 3));
-        i = endIdx + 3;
-        continue;
-      }
-    }
-    if (text[i] === "`") {
-      const endIdx = text.indexOf("`", i + 1);
-      if (endIdx !== -1) {
-        parts.push(text.slice(i, endIdx + 1));
-        i = endIdx + 1;
-        continue;
-      }
-    }
-    if (text[i] === "*" || text[i] === "_") {
-      parts.push(text[i]);
-      i++;
-      continue;
-    }
-    if (text[i] === "[" || text[i] === "(") {
-      parts.push(text[i]);
-      i++;
-      continue;
-    }
-    if (text[i] === "]") {
-      parts.push(text[i]);
-      i++;
-      continue;
-    }
-    const char = text[i];
-    if (SPECIAL_CHARS.has(char)) {
-      parts.push(`\\${char}`);
-    } else {
-      parts.push(char);
-    }
-    i++;
-  }
-  return parts.join("");
-}
-function createEscapeMarkdownMiddleware() {
-  return async (message, next) => {
-    message.text = escapeMarkdownV2(message.text);
-    await next();
-  };
-}
-
 // ../channels/dist/middleware/split-message.js
 var TELEGRAM_MAX = 4096;
 function splitText(text, maxLength) {
@@ -743,6 +776,38 @@ async function withRetry(fn, options) {
   throw lastError;
 }
 
+// ../channels/dist/middleware/markdown-to-html.js
+function markdownToTelegramHtml(text) {
+  if (!text)
+    return "";
+  const placeholders = [];
+  const PH_PREFIX = "\uFFFCPH";
+  const PH_SUFFIX = "\uFFFC";
+  function hold(html) {
+    const idx = placeholders.length;
+    placeholders.push(html);
+    return `${PH_PREFIX}${idx}${PH_SUFFIX}`;
+  }
+  let out = text;
+  out = out.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => hold(lang ? `<pre><code class="language-${escapeHtml(lang)}">${escapeHtml(code.trimEnd())}</code></pre>` : `<pre>${escapeHtml(code.trimEnd())}</pre>`));
+  out = out.replace(/`([^`\n]+)`/g, (_, code) => hold(`<code>${escapeHtml(code)}</code>`));
+  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, linkText, url) => hold(`<a href="${escapeHtml(url)}">${escapeHtml(linkText)}</a>`));
+  out = escapeHtml(out);
+  out = out.replace(/\*\*\*(.+?)\*\*\*/g, "<b><i>$1</i></b>");
+  out = out.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+  out = out.replace(/\*([^*\n]+?)\*/g, "<i>$1</i>");
+  out = out.replace(/~~(.+?)~~/g, "<s>$1</s>");
+  out = out.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
+  out = out.replace(/^&gt;\s?(.*)$/gm, "<blockquote>$1</blockquote>");
+  out = out.replace(/<\/blockquote>\n<blockquote>/g, "\n");
+  const phPattern = new RegExp(`${PH_PREFIX}(\\d+)${PH_SUFFIX}`, "g");
+  out = out.replace(phPattern, (_, idx) => placeholders[Number(idx)]);
+  return out;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
 // ../channels/dist/telegram/media.js
 function registerMediaHandlers(bot, isAllowed, handlers, onRejected) {
   bot.on("message:photo", async (ctx) => {
@@ -807,11 +872,13 @@ var TelegramChannel = class {
   allowedUsers;
   handlers = [];
   sendPipeline;
+  log;
   constructor(config) {
+    this.log = config.logger ?? noopLogger;
     this.bot = new Bot(config.botToken);
     this.allowedUsers = new Set(config.allowedUsers);
     this.bot.catch((err2) => {
-      console.error("[augure:telegram] Bot error:", err2.message ?? err2);
+      this.log.error("Bot error:", err2.message ?? err2);
     });
     this.bot.on("message:text", async (ctx) => {
       const userId = ctx.from.id;
@@ -832,29 +899,26 @@ var TelegramChannel = class {
       }
     });
     registerMediaHandlers(this.bot, (id) => this.isUserAllowed(id), this.handlers, (userId, ts) => this.handleRejected(userId, Math.floor(ts.getTime() / 1e3), config.rejectMessage));
-    const rawSend = async (msg) => {
-      await withRetry(() => this.bot.api.sendMessage(Number(msg.userId), msg.text, {
-        parse_mode: "MarkdownV2",
-        ...msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {}
+    const convertAndSend = async (msg) => {
+      const htmlText = markdownToTelegramHtml(msg.text);
+      const replyOpts = msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {};
+      await withRetry(() => this.bot.api.sendMessage(Number(msg.userId), htmlText, {
+        parse_mode: "HTML",
+        ...replyOpts
       }), { maxRetries: 3, baseDelayMs: 500 }).catch(async () => {
-        await this.bot.api.sendMessage(Number(msg.userId), msg.text, {
-          ...msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {}
-        }).catch((fallbackErr) => {
-          console.error("[augure:telegram] Fallback send also failed:", fallbackErr);
+        await this.bot.api.sendMessage(Number(msg.userId), msg.text, replyOpts).catch((fallbackErr) => {
+          this.log.error("Fallback send also failed:", fallbackErr);
           throw fallbackErr;
         });
       });
     };
-    this.sendPipeline = createOutgoingPipeline([
-      createEscapeMarkdownMiddleware(),
-      createSplitMessageMiddleware(rawSend)
-    ], rawSend);
+    this.sendPipeline = createOutgoingPipeline([createSplitMessageMiddleware(convertAndSend)], convertAndSend);
   }
   isUserAllowed(userId) {
     return this.allowedUsers.has(userId);
   }
   handleRejected(userId, unixTimestamp, rejectMessage) {
-    console.warn(`[augure:telegram] Rejected message from unauthorized user ${userId} at ${new Date(unixTimestamp * 1e3).toISOString()}`);
+    this.log.warn(`Rejected message from unauthorized user ${userId} at ${new Date(unixTimestamp * 1e3).toISOString()}`);
     if (rejectMessage) {
       this.bot.api.sendMessage(userId, rejectMessage).catch(() => {
       });
@@ -888,14 +952,27 @@ var ToolRegistry = class {
     return Array.from(this.tools.values());
   }
   toFunctionSchemas() {
-    return this.list().map((tool) => ({
-      type: "function",
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.parameters
+    return this.list().map((tool) => {
+      let description = tool.description;
+      if (tool.configCheck && this.context) {
+        try {
+          const warning = tool.configCheck(this.context);
+          if (warning) {
+            description += `
+[NOT CONFIGURED] ${warning}`;
+          }
+        } catch {
+        }
       }
-    }));
+      return {
+        type: "function",
+        function: {
+          name: tool.name,
+          description,
+          parameters: tool.parameters
+        }
+      };
+    });
   }
   async execute(name, params) {
     const tool = this.tools.get(name);
@@ -967,7 +1044,7 @@ var memoryWriteTool = {
 // ../tools/dist/schedule.js
 var scheduleTool = {
   name: "schedule",
-  description: "Manage scheduled tasks: create, delete, or list cron jobs",
+  description: "Manage scheduled tasks: create recurring (cron) or one-shot (runAt) jobs, delete, or list them",
   parameters: {
     type: "object",
     properties: {
@@ -977,13 +1054,14 @@ var scheduleTool = {
         description: "The scheduling action to perform"
       },
       id: { type: "string", description: "The schedule ID (for create/delete)" },
-      cron: { type: "string", description: "Cron expression (for create)" },
+      cron: { type: "string", description: "Cron expression for recurring jobs (for create)" },
+      runAt: { type: "string", description: "ISO 8601 date for one-shot jobs, e.g. 2025-03-15T14:00:00Z (for create)" },
       prompt: { type: "string", description: "The prompt to execute on schedule (for create)" }
     },
     required: ["action"]
   },
   execute: async (params, ctx) => {
-    const { action, id, cron, prompt } = params;
+    const { action, id, cron, runAt, prompt } = params;
     try {
       switch (action) {
         case "list": {
@@ -991,22 +1069,29 @@ var scheduleTool = {
           if (jobs.length === 0) {
             return { success: true, output: "No scheduled jobs." };
           }
-          const lines = jobs.map((j) => `- ${j.id}: "${j.prompt}" @ ${j.cron} (${j.enabled ? "enabled" : "disabled"})`);
+          const lines = jobs.map((j) => {
+            const schedule = j.cron ? `cron: ${j.cron}` : `runAt: ${j.runAt}`;
+            return `- ${j.id}: "${j.prompt}" @ ${schedule} (${j.enabled ? "enabled" : "disabled"})`;
+          });
           return { success: true, output: lines.join("\n") };
         }
         case "create": {
-          if (!cron || !prompt) {
-            return { success: false, output: "Missing required fields: cron and prompt" };
+          if (!prompt) {
+            return { success: false, output: "Missing required field: prompt" };
+          }
+          if (!cron && !runAt) {
+            return { success: false, output: "Must provide either cron (recurring) or runAt (one-shot)" };
           }
           const jobId = id ?? `job-${Date.now()}`;
           ctx.scheduler.addJob({
             id: jobId,
             cron,
+            runAt,
             prompt,
             channel: "default",
             enabled: true
           });
-          return { success: true, output: `Created job ${jobId}` };
+          return { success: true, output: `Created job ${jobId} (${cron ? "recurring" : `one-shot at ${runAt}`})` };
         }
         case "delete": {
           if (!id) {
@@ -1027,10 +1112,54 @@ var scheduleTool = {
   }
 };
 
+// ../tools/dist/datetime.js
+var datetimeTool = {
+  name: "datetime",
+  description: "Get the current date and time, optionally in a specific timezone",
+  parameters: {
+    type: "object",
+    properties: {
+      timezone: {
+        type: "string",
+        description: "IANA timezone (e.g. 'Europe/Paris', 'America/New_York'). Defaults to the system timezone."
+      }
+    }
+  },
+  execute: async (params) => {
+    const { timezone } = params;
+    const now = /* @__PURE__ */ new Date();
+    const options = {
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      timeZoneName: "longOffset"
+    };
+    if (timezone) {
+      options.timeZone = timezone;
+    }
+    try {
+      const formatted = new Intl.DateTimeFormat("en-US", options).format(now);
+      return {
+        success: true,
+        output: `${formatted}
+ISO 8601 (UTC): ${now.toISOString()}
+Unix timestamp: ${Math.floor(now.getTime() / 1e3)}`
+      };
+    } catch {
+      return { success: false, output: `Invalid timezone: ${timezone}` };
+    }
+  }
+};
+
 // ../tools/dist/web-search.js
 var webSearchTool = {
   name: "web_search",
   description: "Search the web using the configured search provider (Tavily, Exa, or SearXNG)",
+  configCheck: (ctx) => ctx.config.tools?.webSearch ? null : "This tool requires configuration. See https://augure.dev/docs/tools/web-search",
   parameters: {
     type: "object",
     properties: {
@@ -1242,6 +1371,273 @@ ${text}`;
 // ../tools/dist/email.js
 import { ImapFlow } from "imapflow";
 import { createTransport } from "nodemailer";
+var MAX_BODY_CHARS = 4e3;
+function stripHtml(html) {
+  return html.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n\n").replace(/<\/div>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\n{3,}/g, "\n\n").trim();
+}
+function findTextPart(structure) {
+  if (structure.type === "text/plain" && structure.part) {
+    return { part: structure.part, isHtml: false };
+  }
+  if (structure.type === "text/html" && structure.part) {
+    return { part: structure.part, isHtml: true };
+  }
+  if (structure.childNodes) {
+    let htmlFallback = null;
+    for (const child of structure.childNodes) {
+      const found = findTextPart(child);
+      if (found && !found.isHtml)
+        return found;
+      if (found && found.isHtml)
+        htmlFallback = found;
+    }
+    return htmlFallback;
+  }
+  return null;
+}
+async function withImapClient(config, fn) {
+  const client = new ImapFlow({
+    host: config.host,
+    port: config.port,
+    secure: config.port === 993,
+    auth: { user: config.user, pass: config.password },
+    logger: false
+  });
+  let connected = false;
+  try {
+    await client.connect();
+    connected = true;
+    return await fn(client);
+  } finally {
+    if (connected) {
+      await client.logout();
+    }
+  }
+}
+function formatSummaries(emails) {
+  if (emails.length === 0)
+    return "No emails found.";
+  return emails.map((e, i) => `${i + 1}. ${e.seen ? "" : "[UNREAD] "}UID:${e.uid} Subject: ${e.subject} | From: ${e.from} | Date: ${e.date}`).join("\n");
+}
+function extractAddress(addr) {
+  if (!addr)
+    return "unknown";
+  if (Array.isArray(addr)) {
+    const first = addr[0];
+    if (first && typeof first === "object" && "address" in first) {
+      return first.address;
+    }
+    return String(first ?? "unknown");
+  }
+  if (typeof addr === "object" && "address" in addr) {
+    return addr.address;
+  }
+  return String(addr);
+}
+async function handleList(params, imapConfig) {
+  const folder = params.folder ?? "INBOX";
+  const limit = params.limit ?? 10;
+  return withImapClient(imapConfig, async (client) => {
+    const lock = await client.getMailboxLock(folder);
+    try {
+      const status = client.mailbox;
+      if (!status || status.exists === 0)
+        return "Mailbox is empty.";
+      const start = Math.max(1, status.exists - limit + 1);
+      const emails = [];
+      for await (const msg of client.fetch(`${start}:*`, {
+        envelope: true,
+        flags: true
+      })) {
+        emails.push({
+          uid: msg.uid,
+          subject: msg.envelope?.subject ?? "(no subject)",
+          from: extractAddress(msg.envelope?.from),
+          date: msg.envelope?.date?.toISOString() ?? "unknown",
+          seen: msg.flags?.has("\\Seen") ?? false
+        });
+      }
+      return formatSummaries(emails.slice(-limit));
+    } finally {
+      lock.release();
+    }
+  });
+}
+async function handleRead(params, imapConfig) {
+  const folder = params.folder ?? "INBOX";
+  return withImapClient(imapConfig, async (client) => {
+    const lock = await client.getMailboxLock(folder);
+    try {
+      const msg = await client.fetchOne(String(params.uid), {
+        envelope: true,
+        bodyStructure: true,
+        flags: true,
+        uid: true
+      });
+      if (!msg)
+        return `No email found with UID ${params.uid}.`;
+      let bodyText = "";
+      const textPart = msg.bodyStructure ? findTextPart(msg.bodyStructure) : null;
+      if (textPart) {
+        const { content } = await client.download(String(params.uid), textPart.part, {
+          uid: true
+        });
+        const chunks = [];
+        for await (const chunk of content) {
+          chunks.push(Buffer.from(chunk));
+        }
+        bodyText = Buffer.concat(chunks).toString("utf-8");
+        if (textPart.isHtml)
+          bodyText = stripHtml(bodyText);
+      }
+      if (bodyText.length > MAX_BODY_CHARS) {
+        bodyText = bodyText.slice(0, MAX_BODY_CHARS) + "\n[truncated]";
+      }
+      const wasSeen = msg.flags?.has("\\Seen") ?? false;
+      await client.messageFlagsAdd(String(params.uid), ["\\Seen"], { uid: true });
+      const subject = msg.envelope?.subject ?? "(no subject)";
+      const from = extractAddress(msg.envelope?.from);
+      const date = msg.envelope?.date?.toISOString() ?? "unknown";
+      return `UID: ${params.uid}
+Subject: ${subject}
+From: ${from}
+Date: ${date}
+Status: ${wasSeen ? "was read" : "was unread, marked read"}
+
+${bodyText}`;
+    } finally {
+      lock.release();
+    }
+  });
+}
+async function handleSearch(params, imapConfig) {
+  const folder = params.folder ?? "INBOX";
+  const limit = params.limit ?? 10;
+  return withImapClient(imapConfig, async (client) => {
+    const lock = await client.getMailboxLock(folder);
+    try {
+      const criteria = {};
+      if (params.from)
+        criteria.from = params.from;
+      if (params.subject)
+        criteria.subject = params.subject;
+      if (params.since)
+        criteria.since = new Date(params.since);
+      if (params.unseen)
+        criteria.seen = false;
+      const result = await client.search(criteria, { uid: true });
+      const uids = Array.isArray(result) ? result : [];
+      if (uids.length === 0)
+        return "No emails match the search criteria.";
+      const selected = uids.slice(-limit);
+      const emails = [];
+      for await (const msg of client.fetch(selected, { envelope: true, flags: true }, { uid: true })) {
+        emails.push({
+          uid: msg.uid,
+          subject: msg.envelope?.subject ?? "(no subject)",
+          from: extractAddress(msg.envelope?.from),
+          date: msg.envelope?.date?.toISOString() ?? "unknown",
+          seen: msg.flags?.has("\\Seen") ?? false
+        });
+      }
+      return formatSummaries(emails);
+    } finally {
+      lock.release();
+    }
+  });
+}
+async function handleSend(params, smtpConfig) {
+  const transport = createTransport({
+    host: smtpConfig.host,
+    port: smtpConfig.port,
+    secure: smtpConfig.port === 465,
+    auth: { user: smtpConfig.user, pass: smtpConfig.password }
+  });
+  const info = await transport.sendMail({
+    from: smtpConfig.user,
+    to: params.to,
+    subject: params.subject,
+    text: params.body,
+    cc: params.cc,
+    bcc: params.bcc
+  });
+  return `Email sent. Message ID: ${info.messageId}`;
+}
+var emailTool = {
+  name: "email",
+  description: "Manage email: list recent messages, read by UID, search with criteria, or send an email via SMTP",
+  configCheck: (ctx) => ctx.config.tools?.email ? null : "This tool requires configuration. See https://augure.dev/docs/tools/email",
+  parameters: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["list", "read", "search", "send"],
+        description: "The email action to perform"
+      },
+      folder: {
+        type: "string",
+        description: 'IMAP folder (default: "INBOX"). Used by list, read, search.'
+      },
+      limit: {
+        type: "number",
+        description: "Max emails to return (default: 10). Used by list, search."
+      },
+      uid: { type: "number", description: "Email UID to read. Required for read." },
+      from: { type: "string", description: "Filter by sender address. Used by search." },
+      subject: {
+        type: "string",
+        description: "Filter by subject (search) or email subject (send)."
+      },
+      since: {
+        type: "string",
+        description: "ISO 8601 date \u2014 emails since this date. Used by search."
+      },
+      unseen: { type: "boolean", description: "Only unread emails. Used by search." },
+      to: { type: "string", description: "Recipient address. Required for send." },
+      body: { type: "string", description: "Email body text. Required for send." },
+      cc: { type: "string", description: "CC recipients. Used by send." },
+      bcc: { type: "string", description: "BCC recipients. Used by send." }
+    },
+    required: ["action"]
+  },
+  execute: async (params, ctx) => {
+    const p = params;
+    const emailConfig = ctx.config.tools?.email;
+    if (!emailConfig) {
+      return { success: false, output: "Email is not configured. Add tools.email to your config." };
+    }
+    try {
+      switch (p.action) {
+        case "list":
+          return { success: true, output: await handleList(p, emailConfig.imap) };
+        case "read":
+          if (!p.uid)
+            return { success: false, output: "Missing required field: uid" };
+          return { success: true, output: await handleRead(p, emailConfig.imap) };
+        case "search":
+          if (!p.from && !p.subject && !p.since && p.unseen === void 0)
+            return { success: false, output: "At least one search criterion is required (from, subject, since, or unseen)." };
+          return { success: true, output: await handleSearch(p, emailConfig.imap) };
+        case "send":
+          if (!p.to)
+            return { success: false, output: "Missing required field: to" };
+          if (!p.subject)
+            return { success: false, output: "Missing required field: subject" };
+          if (!p.body)
+            return { success: false, output: "Missing required field: body" };
+          return { success: true, output: await handleSend(p, emailConfig.smtp) };
+        default:
+          return { success: false, output: `Unknown action: ${p.action}` };
+      }
+    } catch (err2) {
+      return {
+        success: false,
+        output: err2 instanceof Error ? err2.message : String(err2)
+      };
+    }
+  }
+};
 
 // ../tools/dist/sandbox-exec.js
 var sandboxExecTool = {
@@ -1320,6 +1716,7 @@ function shellEscape(s) {
 var opencodeTool = {
   name: "opencode",
   description: "Run a code agent (claude-code, opencode, codex CLI) in a Docker container to perform a coding task.",
+  configCheck: (ctx) => ctx.config.sandbox.codeAgent ? null : "This tool requires sandbox.codeAgent configuration. See https://augure.dev/docs/sandbox",
   parameters: {
     type: "object",
     properties: {
@@ -1531,6 +1928,10 @@ var DockerContainer = class {
         }
       });
       this.demux(stream, stdoutPT, stderrPT);
+      stream.on("end", () => {
+        stdoutPT.end();
+        stderrPT.end();
+      });
     });
   }
 };
@@ -1556,6 +1957,7 @@ var DockerContainerPool = class {
   docker;
   image;
   maxTotal;
+  log;
   // C3: idle cache keyed by trust level to prevent cross-trust reuse
   idle = /* @__PURE__ */ new Map([
     ["sandboxed", /* @__PURE__ */ new Set()],
@@ -1567,6 +1969,7 @@ var DockerContainerPool = class {
     this.docker = docker;
     this.image = config.image;
     this.maxTotal = config.maxTotal;
+    this.log = config.logger ?? noopLogger;
   }
   get idleCount() {
     let count = 0;
@@ -1576,18 +1979,22 @@ var DockerContainerPool = class {
   }
   /* ---- acquire ---- */
   async acquire(opts) {
+    this.log.debug(`Acquiring container: trust=${opts.trust} memory=${opts.memory} cpu=${opts.cpu}`);
     const trustIdle = this.idle.get(opts.trust);
     const cached = trustIdle.values().next();
     if (!cached.done) {
       const container2 = cached.value;
       trustIdle.delete(container2);
       this.busy.add(container2);
+      this.log.debug(`Reusing cached container: ${container2.id.slice(0, 12)}`);
       return container2;
     }
     const total = this.idleCount + this.busy.size;
     if (total >= this.maxTotal) {
+      this.log.error(`Pool limit reached: ${total}/${this.maxTotal}`);
       throw new Error("Pool limit reached");
     }
+    this.log.debug("Creating new container...");
     const raw = await this.docker.createContainer(this.buildCreateOpts(opts));
     await raw.start();
     const modem = this.docker.modem;
@@ -1595,6 +2002,7 @@ var DockerContainerPool = class {
     const container = new DockerContainer(raw, demux);
     this.containerTrust.set(container.id, opts.trust);
     this.busy.add(container);
+    this.log.debug(`Container created: ${container.id.slice(0, 12)}`);
     return container;
   }
   /* ---- release ---- */
@@ -1606,6 +2014,7 @@ var DockerContainerPool = class {
     }
     const trust = this.containerTrust.get(container.id) ?? "sandboxed";
     this.idle.get(trust).add(container);
+    this.log.debug(`Container released: ${container.id.slice(0, 12)} \u2192 idle (${trust})`);
   }
   /* ---- destroy ---- */
   async destroy(container) {
@@ -1665,6 +2074,69 @@ var DockerContainerPool = class {
   }
 };
 
+// ../sandbox/dist/ensure-image.js
+import { Readable } from "stream";
+var DOCKERFILE = `FROM node:22-slim
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    python3 curl jq git \\
+  && rm -rf /var/lib/apt/lists/*
+WORKDIR /workspace
+`;
+function buildTar(content) {
+  const data = Buffer.from(content, "utf-8");
+  const name = "Dockerfile";
+  const header = Buffer.alloc(512, 0);
+  header.write(name, 0, 100, "utf-8");
+  header.write("0000644\0", 100, 8, "utf-8");
+  header.write("0000000\0", 108, 8, "utf-8");
+  header.write("0000000\0", 116, 8, "utf-8");
+  header.write(data.length.toString(8).padStart(11, "0") + "\0", 124, 12, "utf-8");
+  header.write(Math.floor(Date.now() / 1e3).toString(8).padStart(11, "0") + "\0", 136, 12, "utf-8");
+  header.write("0", 156, 1, "utf-8");
+  header.fill(32, 148, 156);
+  let checksum = 0;
+  for (let i = 0; i < 512; i++)
+    checksum += header[i];
+  header.write(checksum.toString(8).padStart(6, "0") + "\0 ", 148, 8, "utf-8");
+  const padding = 512 - (data.length % 512 || 512);
+  const dataPadded = padding > 0 && padding < 512 ? Buffer.concat([data, Buffer.alloc(padding, 0)]) : data;
+  const end = Buffer.alloc(1024, 0);
+  return Buffer.concat([header, dataPadded, end]);
+}
+async function ensureImage(docker, imageName, logger) {
+  const log = logger ?? noopLogger;
+  log.debug(`Checking image: ${imageName}`);
+  try {
+    await docker.getImage(imageName).inspect();
+    log.debug("Image exists");
+    return;
+  } catch (err2) {
+    const statusCode = err2.statusCode;
+    if (statusCode !== void 0 && statusCode !== 404)
+      throw err2;
+  }
+  log.info(`Image "${imageName}" not found, building...`);
+  const tar = buildTar(DOCKERFILE);
+  const stream = await docker.buildImage(Readable.from(tar), {
+    t: imageName
+  });
+  await new Promise((resolve5, reject) => {
+    docker.modem.followProgress(stream, (err2) => {
+      if (err2)
+        reject(err2);
+      else
+        resolve5();
+    }, (event) => {
+      if (event.stream) {
+        const line = event.stream.trim();
+        if (line)
+          log.debug(line);
+      }
+    });
+  });
+  log.info(`Image "${imageName}" built`);
+}
+
 // ../memory/dist/store.js
 import { readFile as readFile3, writeFile, mkdir as mkdir2, readdir as readdir2, access } from "fs/promises";
 import { join as join3, dirname, relative } from "path";
@@ -1828,6 +2300,7 @@ var CronScheduler = class {
   store;
   jobs = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
   handlers = [];
   persistChain = Promise.resolve();
   constructor(store) {
@@ -1837,11 +2310,17 @@ var CronScheduler = class {
     this.handlers.push(handler);
   }
   addJob(job) {
-    if (!validate(job.cron)) {
+    if (!job.cron && !job.runAt) {
+      throw new Error(`Job ${job.id} must have either cron or runAt`);
+    }
+    if (job.cron && !validate(job.cron)) {
       throw new Error(`Invalid cron expression: ${job.cron}`);
     }
+    if (job.runAt && isNaN(Date.parse(job.runAt))) {
+      throw new Error(`Invalid runAt date: ${job.runAt}`);
+    }
     this.jobs.set(job.id, job);
-    if (job.enabled) {
+    if (job.enabled && job.cron) {
       const task = createTask(job.cron, () => {
         void this.executeHandlers(job);
       });
@@ -1855,6 +2334,11 @@ var CronScheduler = class {
       task.stop();
       this.tasks.delete(id);
     }
+    const timer = this.timers.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(id);
+    }
     this.jobs.delete(id);
     this.persist();
   }
@@ -1873,6 +2357,9 @@ var CronScheduler = class {
       return;
     const jobs = await this.store.load();
     for (const job of jobs) {
+      if (job.runAt && Date.parse(job.runAt) <= Date.now()) {
+        continue;
+      }
       this.addJob(job);
     }
   }
@@ -1880,11 +2367,32 @@ var CronScheduler = class {
     for (const task of this.tasks.values()) {
       task.start();
     }
+    for (const job of this.jobs.values()) {
+      if (job.enabled && job.runAt && !job.cron) {
+        this.scheduleOneShot(job);
+      }
+    }
   }
   stop() {
     for (const task of this.tasks.values()) {
       task.stop();
     }
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+  }
+  scheduleOneShot(job) {
+    const delayMs = Date.parse(job.runAt) - Date.now();
+    if (delayMs <= 0)
+      return;
+    const timer = setTimeout(() => {
+      this.timers.delete(job.id);
+      void this.executeHandlers(job).then(() => {
+        this.removeJob(job.id);
+      });
+    }, delayMs);
+    this.timers.set(job.id, timer);
   }
   persist() {
     if (!this.store)
@@ -1939,10 +2447,13 @@ Be concise. Only suggest actions that are clearly needed based on the memory con
 var Heartbeat = class {
   config;
   timer;
+  log;
   constructor(config) {
     this.config = config;
+    this.log = config.logger ?? noopLogger;
   }
   async tick() {
+    this.log.debug("Heartbeat tick");
     const memoryContent = await this.loadMemory();
     const messages = [
       { role: "system", content: HEARTBEAT_PROMPT },
@@ -1957,12 +2468,15 @@ ${memoryContent}`
     const response = await this.config.llm.chat(messages);
     const action = this.parseAction(response.content);
     if (action && action.toLowerCase() !== "none") {
+      this.log.debug(`Heartbeat action: ${action}`);
       await this.config.onAction(action);
+    } else {
+      this.log.debug("Heartbeat: no action needed");
     }
   }
   start() {
     this.timer = setInterval(() => {
-      this.tick().catch((err2) => console.error("[augure] Heartbeat error:", err2));
+      this.tick().catch((err2) => this.log.error("Heartbeat error:", err2));
     }, this.config.intervalMs);
   }
   stop() {
@@ -2809,9 +3323,11 @@ var JOB_PREFIX = "skill:";
 var SkillSchedulerBridge = class {
   scheduler;
   manager;
-  constructor(scheduler, manager) {
+  log;
+  constructor(scheduler, manager, logger) {
     this.scheduler = scheduler;
     this.manager = manager;
+    this.log = logger ?? noopLogger;
   }
   /** Register cron jobs for all active cron-triggered skills */
   async syncAll() {
@@ -2830,7 +3346,7 @@ var SkillSchedulerBridge = class {
               enabled: true
             });
           } catch (err2) {
-            console.error(`[skills] Failed to register cron for ${skill.id}:`, err2);
+            this.log.error(`Failed to register cron for ${skill.id}:`, err2);
           }
         }
         existingJobs.delete(jobId);
@@ -3222,6 +3738,17 @@ var SkillUpdater = class {
       };
     }
     const toVersion = newSkill.meta.version;
+    if (!newSkill.meta.sandbox) {
+      await this.config.manager.save(backup);
+      return {
+        skillId,
+        success: false,
+        rolledBack: true,
+        fromVersion,
+        toVersion,
+        error: "Downloaded skill has sandbox disabled \u2014 rejected for security"
+      };
+    }
     const testResult = await this.config.tester.test(newSkill);
     if (testResult.success) {
       await this.config.manager.save(newSkill);
@@ -3295,10 +3822,11 @@ var VersionChecker = class _VersionChecker {
       };
     }
   }
-  /** Compare two semver strings. Returns -1 if a < b, 0 if equal, 1 if a > b */
+  /** Compare two semver strings (MAJOR.MINOR.PATCH only, pre-release suffixes stripped). Returns -1 if a < b, 0 if equal, 1 if a > b */
   static compareVersions(a, b) {
-    const pa = a.split(".").map(Number);
-    const pb = b.split(".").map(Number);
+    const clean = (v) => v.replace(/^v/, "").split("-")[0];
+    const pa = clean(a).split(".").map(Number);
+    const pb = clean(b).split(".").map(Number);
     for (let i = 0; i < 3; i++) {
       const va = pa[i] ?? 0;
       const vb = pb[i] ?? 0;
@@ -3312,27 +3840,48 @@ var VersionChecker = class _VersionChecker {
 };
 
 // ../core/dist/main.js
-var SYSTEM_PROMPT = `You are Augure, a personal AI assistant. You are proactive, helpful, and concise.
+var BASE_SYSTEM_PROMPT = `You are Augure, a personal AI assistant. You are proactive, helpful, and concise.
 You speak the same language as the user. You have access to tools and persistent memory.
-Always be direct and actionable.`;
-function resolveLLMClient(config, usage) {
+Always be direct and actionable.
+
+## Your capabilities
+
+You have access to tools that let you interact with the outside world. Use the datetime tool when the user needs precise time information beyond what is shown in the current date above. Use memory tools to remember and recall information across conversations. Use the schedule tool to create recurring or one-shot tasks.
+
+If a tool is marked as [NOT CONFIGURED], let the user know it needs to be set up first and share the documentation link from the tool description.`;
+var SKILLS_PROMPT = `
+## Skills
+
+You can create and manage "skills" \u2014 autonomous code units that run in isolated Docker containers. Skills are powerful: they let you automate tasks, run on a schedule, and self-heal when they break.
+
+- Use skill_list to see existing skills and their status
+- Use skill_generate to create a new skill from a natural language description
+- Use skill_run to execute a skill manually
+- Use skill_heal to fix a broken skill
+- Use skill_install to install a skill from the hub
+
+When a user asks to automate a recurring task (e.g. "check this every morning", "send me a summary daily"), suggest creating a skill with a cron trigger. Skills can also be triggered manually or by events.`;
+function resolveLLMClient(config, usage, logger) {
   const override = usage !== "default" ? config[usage] : void 0;
   return new OpenRouterClient({
     apiKey: override?.apiKey ?? config.default.apiKey,
     model: override?.model ?? config.default.model,
-    maxTokens: override?.maxTokens ?? config.default.maxTokens
+    maxTokens: override?.maxTokens ?? config.default.maxTokens,
+    logger: logger.child("llm")
   });
 }
-async function startAgent(configPath) {
+async function startAgent(configPath, opts) {
+  const log = createLogger({ level: opts?.debug ? "debug" : "info" });
   const config = await loadConfig(configPath);
-  console.log(`[augure] Loaded config: ${config.identity.name}`);
+  log.info(`Loaded config: ${config.identity.name}`);
+  log.debug(`Config path: ${configPath}`);
   let telegram;
-  const llm = resolveLLMClient(config.llm, "default");
-  const ingestionLLM = resolveLLMClient(config.llm, "ingestion");
-  const monitoringLLM = resolveLLMClient(config.llm, "monitoring");
+  const llm = resolveLLMClient(config.llm, "default", log);
+  const ingestionLLM = resolveLLMClient(config.llm, "ingestion", log);
+  const monitoringLLM = resolveLLMClient(config.llm, "monitoring", log);
   const memoryPath = resolve(configPath, "..", config.memory.path);
   const memory = new FileMemoryStore(memoryPath);
-  console.log(`[augure] Memory store: ${memoryPath}`);
+  log.info(`Memory store: ${memoryPath}`);
   const retriever = new MemoryRetriever(memory, {
     maxTokens: config.memory.maxRetrievalTokens
   });
@@ -3341,31 +3890,37 @@ async function startAgent(configPath) {
   tools.register(memoryReadTool);
   tools.register(memoryWriteTool);
   tools.register(scheduleTool);
+  tools.register(datetimeTool);
   tools.register(webSearchTool);
   tools.register(httpTool);
+  tools.register(emailTool);
   tools.register(sandboxExecTool);
   tools.register(opencodeTool);
   const jobStorePath = resolve(configPath, "..", "jobs.json");
   const jobStore = new JobStore(jobStorePath);
   const scheduler = new CronScheduler(jobStore);
   await scheduler.loadPersistedJobs();
-  console.log(`[augure] Loaded ${scheduler.listJobs().length} persisted jobs`);
+  log.info(`Loaded ${scheduler.listJobs().length} persisted jobs`);
   for (const job of config.scheduler.jobs) {
     if (!scheduler.listJobs().some((j) => j.id === job.id)) {
       scheduler.addJob({ ...job, enabled: true });
     }
   }
   const docker = new Dockerode();
+  const sandboxImage = config.sandbox.image ?? "augure-sandbox:latest";
+  const sandboxLog = log.child("sandbox");
+  await ensureImage(docker, sandboxImage, sandboxLog);
   const pool = new DockerContainerPool(docker, {
-    image: config.sandbox.image ?? "augure-sandbox:latest",
-    maxTotal: config.security.maxConcurrentSandboxes
+    image: sandboxImage,
+    maxTotal: config.security.maxConcurrentSandboxes,
+    logger: sandboxLog
   });
-  console.log(`[augure] Container pool created (max: ${config.security.maxConcurrentSandboxes})`);
+  log.info(`Container pool: max=${config.security.maxConcurrentSandboxes}`);
   let skillManagerRef;
   let skillUpdater;
   if (config.skills) {
     const skillsPath = resolve(configPath, "..", config.skills.path);
-    const codingLLM = resolveLLMClient(config.llm, "coding");
+    const codingLLM = resolveLLMClient(config.llm, "coding", log);
     const skillManager = new SkillManager(skillsPath);
     const skillGenerator = new SkillGenerator(codingLLM);
     const skillRunner = new SkillRunner({
@@ -3409,63 +3964,71 @@ async function startAgent(configPath) {
         const updated = updateResults.filter((r) => r.success);
         const failed = updateResults.filter((r) => !r.success);
         if (updated.length > 0) {
-          console.log(`[augure] Skills updated: ${updated.map((r) => `${r.skillId} (v${r.fromVersion}\u2192v${r.toVersion})`).join(", ")}`);
+          log.info(`Skills updated: ${updated.map((r) => `${r.skillId} (v${r.fromVersion}\u2192v${r.toVersion})`).join(", ")}`);
         }
         if (failed.length > 0) {
-          console.log(`[augure] Skill updates failed: ${failed.map((r) => `${r.skillId}: ${r.error}`).join(", ")}`);
+          log.warn(`Skill updates failed: ${failed.map((r) => `${r.skillId}: ${r.error}`).join(", ")}`);
         }
       } catch (err2) {
-        console.error("[augure] Skill update check failed:", err2);
+        log.error("Skill update check failed:", err2);
       }
     }
     skillManagerRef = skillManager;
-    console.log(`[augure] Skills system initialized at ${skillsPath}`);
+    log.info(`Skills initialized: ${skillsPath}`);
   }
   tools.setContext({ config, memory, scheduler, pool });
   const auditConfig = config.audit ?? { path: "./logs", enabled: true };
   const auditPath = resolve(configPath, "..", auditConfig.path);
-  const audit = auditConfig.enabled ? new FileAuditLogger(auditPath) : new NullAuditLogger();
-  console.log(`[augure] Audit logger: ${auditConfig.enabled ? auditPath : "disabled"}`);
+  const audit = auditConfig.enabled ? new FileAuditLogger(auditPath, log.child("audit")) : new NullAuditLogger();
+  log.info(`Audit: ${auditConfig.enabled ? auditPath : "disabled"}`);
   let personaResolver;
   if (config.persona) {
     const personaPath = resolve(configPath, "..", config.persona.path);
     personaResolver = new PersonaResolver(personaPath);
     await personaResolver.loadAll();
-    console.log(`[augure] Personas loaded from ${personaPath}`);
+    log.info(`Personas: ${personaPath}`);
   }
-  if (config.updates?.cli?.enabled !== false) {
+  let cliVersion;
+  try {
     const require3 = createRequire(import.meta.url);
-    const { version: version2 } = require3("augure/package.json");
+    const pkg = require3("augure/package.json");
+    cliVersion = pkg.version;
+  } catch {
+  }
+  if (cliVersion && config.updates?.cli?.enabled !== false) {
     const versionChecker = new VersionChecker({
-      currentVersion: version2,
-      packageName: "augure",
-      githubRepo: "FaureAlexis/augure"
+      currentVersion: cliVersion,
+      packageName: "augure"
     });
     const versionResult = await versionChecker.check();
     if (versionResult.updateAvailable) {
-      console.log(`[augure] Update available: v${versionResult.latestVersion} (current: v${versionResult.currentVersion}). Run: npm update -g augure`);
+      log.warn(`Update available: v${versionResult.latestVersion} (current: v${versionResult.currentVersion}). Run: npm update -g augure`);
     }
   }
   const guard = new ContextGuard({
     maxContextTokens: 2e5,
     reservedForOutput: config.llm.default.maxTokens ?? 8192
   });
+  const systemPrompt = config.skills ? BASE_SYSTEM_PROMPT + SKILLS_PROMPT : BASE_SYSTEM_PROMPT;
   const agent = new Agent({
     llm,
     tools,
-    systemPrompt: SYSTEM_PROMPT,
+    systemPrompt,
     memoryContent: "",
     retriever,
     ingester,
     audit,
     guard,
-    modelName: config.llm.default.model
+    modelName: config.llm.default.model,
+    logger: log.child("agent")
   });
   if (config.channels.telegram?.enabled) {
+    const telegramLog = log.child("telegram");
     telegram = new TelegramChannel({
       botToken: config.channels.telegram.botToken,
       allowedUsers: config.channels.telegram.allowedUsers,
-      rejectMessage: config.channels.telegram.rejectMessage
+      rejectMessage: config.channels.telegram.rejectMessage,
+      logger: telegramLog
     });
     const tg = telegram;
     const commandCtx = {
@@ -3475,7 +4038,7 @@ async function startAgent(configPath) {
       skillManager: skillManagerRef
     };
     tg.onMessage(async (msg) => {
-      console.log(`[augure] Message from ${msg.userId}: ${msg.text}`);
+      log.info(`Message from ${msg.userId}: ${msg.text}`);
       try {
         const cmdResult = await handleCommand(msg.text, commandCtx);
         if (cmdResult.handled) {
@@ -3498,7 +4061,7 @@ async function startAgent(configPath) {
           replyTo: msg.id
         });
       } catch (err2) {
-        console.error("[augure] Error handling message:", err2);
+        log.error("Error handling message:", err2);
         await tg.send({
           channelType: "telegram",
           userId: msg.userId,
@@ -3507,15 +4070,16 @@ async function startAgent(configPath) {
       }
     });
     await tg.start();
-    console.log("[augure] Telegram bot started. Waiting for messages...");
+    log.info("Telegram bot started");
   }
   const heartbeatIntervalMs = parseInterval(config.scheduler.heartbeatInterval);
   const heartbeat = new Heartbeat({
     llm: monitoringLLM,
     memory,
     intervalMs: heartbeatIntervalMs,
+    logger: log.child("heartbeat"),
     onAction: async (action) => {
-      console.log(`[augure] Heartbeat action: ${action}`);
+      log.info(`Heartbeat action: ${action}`);
       const response = await agent.handleMessage({
         id: `heartbeat-${Date.now()}`,
         channelType: "system",
@@ -3523,39 +4087,59 @@ async function startAgent(configPath) {
         text: `[Heartbeat] ${action}`,
         timestamp: /* @__PURE__ */ new Date()
       });
-      console.log(`[augure] Heartbeat response: ${response}`);
+      log.debug(`Heartbeat response: ${response.slice(0, 200)}`);
     }
   });
+  scheduler.onJobTrigger(async (job) => {
+    log.info(`Job triggered: ${job.id}`);
+    const response = await agent.handleMessage({
+      id: `job-${job.id}-${Date.now()}`,
+      channelType: "system",
+      userId: "system",
+      text: job.prompt,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (telegram && config.channels.telegram?.enabled) {
+      const userId = config.channels.telegram.allowedUsers[0];
+      if (userId !== void 0) {
+        await telegram.send({
+          channelType: "telegram",
+          userId: String(userId),
+          text: response
+        });
+      }
+    }
+    log.debug(`Job ${job.id} completed`);
+  });
   scheduler.start();
   heartbeat.start();
-  console.log(`[augure] Scheduler started with ${scheduler.listJobs().length} jobs. Heartbeat every ${config.scheduler.heartbeatInterval}.`);
+  log.info(`Scheduler started: ${scheduler.listJobs().length} jobs, heartbeat every ${config.scheduler.heartbeatInterval}`);
+  const updateTimers = [];
   if (skillUpdater && config.updates?.skills?.checkInterval) {
+    const su = skillUpdater;
     const skillCheckMs = parseInterval(config.updates.skills.checkInterval);
-    setInterval(async () => {
+    updateTimers.push(setInterval(async () => {
       try {
-        const results = await skillUpdater.checkAndApply();
+        const results = await su.checkAndApply();
         for (const r of results) {
           if (r.success) {
-            console.log(`[augure] Skill auto-updated: ${r.skillId} v${r.fromVersion}\u2192v${r.toVersion}`);
+            log.info(`Skill auto-updated: ${r.skillId} v${r.fromVersion}\u2192v${r.toVersion}`);
           } else if (r.rolledBack) {
-            console.log(`[augure] Skill update rolled back: ${r.skillId} - ${r.error}`);
+            log.warn(`Skill update rolled back: ${r.skillId} - ${r.error}`);
           }
         }
       } catch (err2) {
-        console.error("[augure] Periodic skill update check failed:", err2);
+        log.error("Periodic skill update check failed:", err2);
       }
-    }, skillCheckMs);
+    }, skillCheckMs));
   }
-  if (config.updates?.cli?.enabled !== false && config.channels.telegram?.enabled) {
+  if (cliVersion && config.updates?.cli?.enabled !== false && config.channels.telegram?.enabled) {
     const cliCheckMs = parseInterval(config.updates?.cli?.checkInterval ?? "24h");
-    const require3 = createRequire(import.meta.url);
-    const { version: version2 } = require3("augure/package.json");
     const versionChecker = new VersionChecker({
-      currentVersion: version2,
-      packageName: "augure",
-      githubRepo: "FaureAlexis/augure"
+      currentVersion: cliVersion,
+      packageName: "augure"
     });
-    setInterval(async () => {
+    updateTimers.push(setInterval(async () => {
       try {
         const result = await versionChecker.check();
         if (result.updateAvailable && telegram) {
@@ -3570,35 +4154,27 @@ Run: \`npm update -g augure\``
           }
         }
       } catch (err2) {
-        console.error("[augure] CLI version check failed:", err2);
+        log.error("CLI version check failed:", err2);
       }
-    }, cliCheckMs);
+    }, cliCheckMs));
   }
   const shutdown = async () => {
-    console.log("\n[augure] Shutting down...");
+    log.info("Shutting down...");
+    for (const timer of updateTimers)
+      clearInterval(timer);
     heartbeat.stop();
     scheduler.stop();
     if (telegram)
       await telegram.stop();
     await pool.destroyAll();
     await audit.close();
-    console.log("[augure] All containers destroyed");
+    log.info("All containers destroyed");
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
 
-// src/colors.ts
-import { styleText } from "util";
-var brand = (s) => styleText("yellow", s);
-var ok = (s) => styleText("green", s);
-var err = (s) => styleText("red", s);
-var dim = (s) => styleText("dim", s);
-var bold = (s) => styleText("bold", s);
-var cyan = (s) => styleText("cyan", s);
-var prefix = brand("\u25B2 augure");
-
 // src/commands/start.ts
 var startCommand = defineCommand({
   meta: {
@@ -3616,21 +4192,28 @@ var startCommand = defineCommand({
       type: "string",
       description: "Path to .env file",
       alias: "e"
+    },
+    debug: {
+      type: "boolean",
+      description: "Enable debug logging",
+      alias: "d",
+      default: false
     }
   },
   async run({ args }) {
     const configPath = resolve2(args.config);
+    const log = createLogger({ level: args.debug ? "debug" : "info" });
     const envPath = args.env ? resolve2(args.env) : join6(dirname4(configPath), ".env");
     try {
       process.loadEnvFile(envPath);
-      console.log(`${prefix} Loaded env from ${dim(envPath)}`);
+      log.debug(`Loaded env from ${envPath}`);
     } catch {
     }
-    console.log(`${prefix} Starting with config: ${dim(configPath)}`);
+    log.info(`Starting with config: ${configPath}`);
     try {
-      await startAgent(configPath);
+      await startAgent(configPath, { debug: args.debug });
     } catch (e) {
-      console.error(`${prefix} ${err("Fatal error:")} ${e instanceof Error ? e.message : e}`);
+      log.error("Fatal:", e instanceof Error ? e.message : String(e));
       process.exit(1);
     }
   }
@@ -3640,6 +4223,18 @@ var startCommand = defineCommand({
 import { defineCommand as defineCommand2 } from "citty";
 import { writeFile as writeFile5, access as access3 } from "fs/promises";
 import { resolve as resolve3 } from "path";
+
+// src/colors.ts
+import { styleText as styleText2 } from "util";
+var brand = (s) => styleText2("yellow", s);
+var ok = (s) => styleText2("green", s);
+var err = (s) => styleText2("red", s);
+var dim = (s) => styleText2("dim", s);
+var bold = (s) => styleText2("bold", s);
+var cyan = (s) => styleText2("cyan", s);
+var prefix = brand("\u25B2 augure");
+
+// src/commands/init.ts
 var CONFIG_TEMPLATE = `{
   // Identity
   identity: {