augure 0.3.0 → 0.4.2

package/dist/bin.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { defineCommand as defineCommand4, runMain } from "citty";
 
 // src/commands/start.ts
 import { defineCommand } from "citty";
-import { resolve as resolve2 } from "path";
+import { resolve as resolve2, dirname as dirname4, join as join6 } from "path";
 
 // ../core/dist/config.js
 import { readFile } from "fs/promises";
@@ -35,7 +35,8 @@ var AppConfigSchema = z.object({
     telegram: z.object({
       enabled: z.boolean(),
       botToken: z.string(),
-      allowedUsers: z.array(z.number())
+      allowedUsers: z.array(z.number()),
+      rejectMessage: z.string().optional()
     }).optional(),
     whatsapp: z.object({ enabled: z.boolean() }).optional(),
     web: z.object({ enabled: z.boolean(), port: z.number() }).optional()
@@ -120,6 +121,17 @@ var AppConfigSchema = z.object({
   }).optional(),
   persona: z.object({
     path: z.string().min(1).default("./config/personas")
+  }).optional(),
+  updates: z.object({
+    skills: z.object({
+      enabled: z.boolean().default(true),
+      checkInterval: z.string().min(1).default("6h")
+    }).optional(),
+    cli: z.object({
+      enabled: z.boolean().default(true),
+      checkInterval: z.string().min(1).default("24h"),
+      notifyChannel: z.string().min(1).default("telegram")
+    }).optional()
   }).optional()
 });
 function interpolateEnvVars(raw) {
@@ -150,7 +162,7 @@ var OpenRouterClient = class {
     this.maxTokens = config.maxTokens;
     this.baseUrl = config.baseUrl ?? "https://openrouter.ai/api/v1";
   }
-  async chat(messages) {
+  async chat(messages, tools) {
     const response = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
@@ -163,8 +175,19 @@ var OpenRouterClient = class {
         messages: messages.map((m) => ({
           role: m.role,
           content: m.content,
-          ...m.toolCallId ? { tool_call_id: m.toolCallId } : {}
-        }))
+          ...m.toolCallId ? { tool_call_id: m.toolCallId } : {},
+          ...m.toolCalls?.length ? {
+            tool_calls: m.toolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function",
+              function: {
+                name: tc.name,
+                arguments: JSON.stringify(tc.arguments)
+              }
+            }))
+          } : {}
+        })),
+        ...tools?.length ? { tools } : {}
       })
     });
     if (!response.ok) {
@@ -175,11 +198,15 @@ var OpenRouterClient = class {
     const choice = data.choices[0];
     return {
       content: choice.message.content ?? "",
-      toolCalls: (choice.message.tool_calls ?? []).map((tc) => ({
-        id: tc.id,
-        name: tc.function.name,
-        arguments: JSON.parse(tc.function.arguments)
-      })),
+      toolCalls: (choice.message.tool_calls ?? []).map((tc) => {
+        let args = {};
+        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);
+        }
+        return { id: tc.id, name: tc.function.name, arguments: args };
+      }),
       usage: {
         inputTokens: data.usage.prompt_tokens,
         outputTokens: data.usage.completion_tokens
@@ -190,7 +217,7 @@ var OpenRouterClient = class {
 
 // ../core/dist/context.js
 function assembleContext(input) {
-  const { systemPrompt, memoryContent, toolSchemas, conversationHistory, persona } = input;
+  const { systemPrompt, memoryContent, conversationHistory, persona } = input;
   let system = systemPrompt;
   if (persona) {
     system += `
@@ -203,13 +230,6 @@ ${persona}`;
 
 ## Memory
 ${memoryContent}`;
-  }
-  if (toolSchemas.length > 0) {
-    const toolList = toolSchemas.map((s) => `- **${s.function.name}**: ${s.function.description}`).join("\n");
-    system += `
-
-## Available Tools
-${toolList}`;
   }
   const messages = [{ role: "system", content: system }];
   messages.push(...conversationHistory);
@@ -258,7 +278,7 @@ var NullAuditLogger = class {
 // ../core/dist/agent.js
 var Agent = class {
   config;
-  conversationHistory = [];
+  conversations = /* @__PURE__ */ new Map();
   state = "running";
   constructor(config) {
     this.config = config;
@@ -277,30 +297,33 @@ var Agent = class {
       return "Agent is in emergency stop mode. Send /resume to reactivate.";
     }
     const start = Date.now();
-    this.conversationHistory.push({
+    const userId = incoming.userId;
+    let history = this.conversations.get(userId) ?? [];
+    history.push({
       role: "user",
       content: incoming.text
     });
     if (this.config.guard) {
-      this.conversationHistory = this.config.guard.compact(this.conversationHistory);
+      history = this.config.guard.compact(history);
     }
+    this.conversations.set(userId, history);
     let memoryContent = this.config.memoryContent;
     if (this.config.retriever) {
       memoryContent = await this.config.retriever.retrieve();
     }
     const maxLoops = this.config.maxToolLoops ?? 10;
     let loopCount = 0;
+    const toolSchemas = this.config.tools.toFunctionSchemas();
     while (loopCount < maxLoops) {
       const messages = assembleContext({
         systemPrompt: this.config.systemPrompt,
         memoryContent,
-        toolSchemas: this.config.tools.toFunctionSchemas(),
-        conversationHistory: this.conversationHistory,
+        conversationHistory: history,
         persona: this.config.persona
       });
-      const response = await this.config.llm.chat(messages);
+      const response = await this.config.llm.chat(messages, toolSchemas);
       if (response.toolCalls.length === 0) {
-        this.conversationHistory.push({
+        history.push({
           role: "assistant",
           content: response.content
         });
@@ -321,18 +344,19 @@ var Agent = class {
           });
         }
         if (this.config.ingester) {
-          this.config.ingester.ingest(this.conversationHistory).catch((err2) => console.error("[augure] Ingestion error:", err2));
+          this.config.ingester.ingest(history).catch((err2) => console.error("[augure] Ingestion error:", err2));
         }
         return response.content;
       }
-      this.conversationHistory.push({
+      history.push({
         role: "assistant",
-        content: response.content || ""
+        content: response.content || "",
+        toolCalls: response.toolCalls
       });
       for (const toolCall of response.toolCalls) {
         const toolStart = Date.now();
         const result = await this.config.tools.execute(toolCall.name, toolCall.arguments);
-        this.conversationHistory.push({
+        history.push({
           role: "tool",
           content: result.output,
           toolCallId: toolCall.id
@@ -354,11 +378,22 @@ var Agent = class {
     }
     return "Max tool call loops reached. Please try again.";
   }
-  getConversationHistory() {
-    return [...this.conversationHistory];
+  getConversationHistory(userId) {
+    if (userId) {
+      return [...this.conversations.get(userId) ?? []];
+    }
+    const all = [];
+    for (const msgs of this.conversations.values()) {
+      all.push(...msgs);
+    }
+    return all;
   }
-  clearHistory() {
-    this.conversationHistory = [];
+  clearHistory(userId) {
+    if (userId) {
+      this.conversations.delete(userId);
+    } else {
+      this.conversations.clear();
+    }
   }
 };
 
@@ -528,19 +563,260 @@ var ContextGuard = class {
   }
 };
 
-// ../channels/dist/telegram.js
+// ../channels/dist/telegram/telegram.js
 import { Bot } from "grammy";
+
+// ../channels/dist/pipeline.js
+function createOutgoingPipeline(middlewares, send) {
+  return async (message) => {
+    let index = 0;
+    const next = async () => {
+      if (index < middlewares.length) {
+        const mw = middlewares[index++];
+        await mw(message, next);
+      } else {
+        await send(message);
+      }
+    };
+    await next();
+  };
+}
+
+// ../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) {
+  if (text.length <= maxLength)
+    return [text];
+  const chunks = [];
+  let remaining = text;
+  let openCodeBlock = null;
+  while (remaining.length > 0) {
+    const prefix2 = openCodeBlock ? `${openCodeBlock}
+` : "";
+    const effectiveMax = maxLength - prefix2.length;
+    if (remaining.length <= effectiveMax) {
+      chunks.push(prefix2 + remaining);
+      break;
+    }
+    let splitAt = -1;
+    const searchArea = remaining.slice(0, effectiveMax);
+    const paraIdx = searchArea.lastIndexOf("\n\n");
+    if (paraIdx > effectiveMax * 0.3) {
+      splitAt = paraIdx;
+    }
+    if (splitAt === -1) {
+      const newlineIdx = searchArea.lastIndexOf("\n");
+      if (newlineIdx > effectiveMax * 0.3) {
+        splitAt = newlineIdx;
+      }
+    }
+    if (splitAt === -1) {
+      splitAt = effectiveMax;
+    }
+    let chunk = remaining.slice(0, splitAt);
+    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
+    const fenceMatches = chunk.match(/```/g);
+    const fenceCount = fenceMatches ? fenceMatches.length : 0;
+    if (openCodeBlock) {
+      chunk = prefix2 + chunk;
+      if (fenceCount % 2 === 1) {
+        openCodeBlock = null;
+      } else {
+        chunk += "\n```";
+      }
+    } else {
+      if (fenceCount % 2 === 1) {
+        const lastFenceIdx = chunk.lastIndexOf("```");
+        const afterFence = chunk.slice(lastFenceIdx + 3);
+        const langMatch = afterFence.match(/^(\w*)/);
+        openCodeBlock = "```" + (langMatch?.[1] ?? "");
+        chunk += "\n```";
+      }
+    }
+    chunks.push(chunk);
+  }
+  return chunks.length === 0 ? [""] : chunks;
+}
+function createSplitMessageMiddleware(sendFn, maxLength = TELEGRAM_MAX) {
+  return async (message, next) => {
+    const chunks = splitText(message.text, maxLength);
+    if (chunks.length <= 1) {
+      await next();
+      return;
+    }
+    for (let i = 0; i < chunks.length; i++) {
+      await sendFn({
+        ...message,
+        text: chunks[i],
+        replyTo: i === 0 ? message.replyTo : void 0
+      });
+      if (i < chunks.length - 1) {
+        await new Promise((r) => setTimeout(r, 50));
+      }
+    }
+  };
+}
+
+// ../channels/dist/middleware/error-handler.js
+function isRetryable(error) {
+  if (error instanceof Error) {
+    const err2 = error;
+    const status = err2.status ?? err2.error_code;
+    if (status === 429 || status !== void 0 && status >= 500)
+      return true;
+    if (status !== void 0 && status >= 400 && status < 500)
+      return false;
+    return true;
+  }
+  return false;
+}
+async function withRetry(fn, options) {
+  let lastError;
+  for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err2) {
+      lastError = err2;
+      if (!isRetryable(err2) || attempt === options.maxRetries) {
+        throw err2;
+      }
+      const delay = options.baseDelayMs * Math.pow(2, attempt);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}
+
+// ../channels/dist/telegram/media.js
+function registerMediaHandlers(bot, isAllowed, handlers, onRejected) {
+  bot.on("message:photo", async (ctx) => {
+    const userId = ctx.from.id;
+    if (!isAllowed(userId)) {
+      onRejected?.(userId, new Date(ctx.message.date * 1e3));
+      return;
+    }
+    const photos = ctx.message.photo;
+    const largest = photos[photos.length - 1];
+    const attachment = {
+      type: "photo",
+      fileId: largest.file_id,
+      caption: ctx.message.caption ?? void 0
+    };
+    const incoming = {
+      id: String(ctx.message.message_id),
+      channelType: "telegram",
+      userId: String(userId),
+      text: ctx.message.caption ?? "[Photo]",
+      timestamp: new Date(ctx.message.date * 1e3),
+      replyTo: ctx.message.reply_to_message ? String(ctx.message.reply_to_message.message_id) : void 0,
+      attachments: [attachment]
+    };
+    for (const handler of handlers) {
+      await handler(incoming);
+    }
+  });
+  bot.on("message:document", async (ctx) => {
+    const userId = ctx.from.id;
+    if (!isAllowed(userId)) {
+      onRejected?.(userId, new Date(ctx.message.date * 1e3));
+      return;
+    }
+    const doc = ctx.message.document;
+    const attachment = {
+      type: "document",
+      fileId: doc.file_id,
+      fileName: doc.file_name ?? void 0,
+      mimeType: doc.mime_type ?? void 0,
+      caption: ctx.message.caption ?? void 0
+    };
+    const incoming = {
+      id: String(ctx.message.message_id),
+      channelType: "telegram",
+      userId: String(userId),
+      text: ctx.message.caption ?? `[Document: ${doc.file_name ?? "unknown"}]`,
+      timestamp: new Date(ctx.message.date * 1e3),
+      replyTo: ctx.message.reply_to_message ? String(ctx.message.reply_to_message.message_id) : void 0,
+      attachments: [attachment]
+    };
+    for (const handler of handlers) {
+      await handler(incoming);
+    }
+  });
+}
+
+// ../channels/dist/telegram/telegram.js
 var TelegramChannel = class {
   type = "telegram";
   bot;
   allowedUsers;
   handlers = [];
+  sendPipeline;
   constructor(config) {
     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.bot.on("message:text", async (ctx) => {
       const userId = ctx.from.id;
       if (!this.isUserAllowed(userId)) {
+        this.handleRejected(userId, ctx.message.date, config.rejectMessage);
         return;
       }
       const incoming = {
@@ -555,10 +831,35 @@ var TelegramChannel = class {
         await handler(incoming);
       }
     });
+    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) } } : {}
+      }), { 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);
+          throw fallbackErr;
+        });
+      });
+    };
+    this.sendPipeline = createOutgoingPipeline([
+      createEscapeMarkdownMiddleware(),
+      createSplitMessageMiddleware(rawSend)
+    ], rawSend);
   }
   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()}`);
+    if (rejectMessage) {
+      this.bot.api.sendMessage(userId, rejectMessage).catch(() => {
+      });
+    }
+  }
   onMessage(handler) {
     this.handlers.push(handler);
   }
@@ -569,10 +870,7 @@ var TelegramChannel = class {
     await this.bot.stop();
   }
   async send(message) {
-    await this.bot.api.sendMessage(Number(message.userId), message.text, {
-      parse_mode: "Markdown",
-      ...message.replyTo ? { reply_parameters: { message_id: Number(message.replyTo) } } : {}
-    });
+    await this.sendPipeline(message);
   }
 };
 
@@ -2870,8 +3168,150 @@ async function installBuiltins(manager) {
   }
 }
 
+// ../skills/dist/updater.js
+var SkillUpdater = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Compare local skill versions with hub manifest */
+  async checkForUpdates() {
+    const [local, remote] = await Promise.all([
+      this.config.manager.list(),
+      this.config.hub.list()
+    ]);
+    const localMap = new Map(local.map((s) => [s.id, s.version]));
+    const updates = [];
+    for (const entry of remote) {
+      const localVersion = localMap.get(entry.id);
+      if (localVersion !== void 0 && entry.version > localVersion) {
+        updates.push({
+          id: entry.id,
+          localVersion,
+          hubVersion: entry.version
+        });
+      }
+    }
+    return updates;
+  }
+  /** Apply a single skill update with backup and rollback */
+  async applyUpdate(skillId) {
+    let backup;
+    try {
+      backup = await this.config.manager.get(skillId);
+    } catch (err2) {
+      return {
+        skillId,
+        success: false,
+        fromVersion: 0,
+        toVersion: 0,
+        error: `Failed to backup: ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+    const fromVersion = backup.meta.version;
+    let newSkill;
+    try {
+      newSkill = await this.config.hub.download(skillId);
+    } catch (err2) {
+      return {
+        skillId,
+        success: false,
+        fromVersion,
+        toVersion: 0,
+        error: `Failed to download: ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+    const toVersion = newSkill.meta.version;
+    const testResult = await this.config.tester.test(newSkill);
+    if (testResult.success) {
+      await this.config.manager.save(newSkill);
+      return { skillId, success: true, fromVersion, toVersion };
+    }
+    await this.config.manager.save(backup);
+    return {
+      skillId,
+      success: false,
+      rolledBack: true,
+      fromVersion,
+      toVersion,
+      error: `Update failed tests: ${testResult.error ?? "unknown"}`
+    };
+  }
+  /** Check for updates and apply all available ones */
+  async checkAndApply() {
+    const updates = await this.checkForUpdates();
+    const results = [];
+    for (const update of updates) {
+      try {
+        const result = await this.applyUpdate(update.id);
+        results.push(result);
+      } catch (err2) {
+        results.push({
+          skillId: update.id,
+          success: false,
+          fromVersion: update.localVersion,
+          toVersion: update.hubVersion,
+          error: err2 instanceof Error ? err2.message : String(err2)
+        });
+      }
+    }
+    return results;
+  }
+};
+
 // ../core/dist/main.js
 import { resolve } from "path";
+import { createRequire } from "module";
+
+// ../core/dist/version-checker.js
+var VersionChecker = class _VersionChecker {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Check npm registry for latest version */
+  async check() {
+    try {
+      const response = await fetch(`https://registry.npmjs.org/${this.config.packageName}/latest`);
+      if (!response.ok) {
+        return {
+          updateAvailable: false,
+          currentVersion: this.config.currentVersion,
+          error: `npm registry returned ${response.status}`
+        };
+      }
+      const data = await response.json();
+      const latest = data.version;
+      return {
+        updateAvailable: _VersionChecker.compareVersions(this.config.currentVersion, latest) < 0,
+        currentVersion: this.config.currentVersion,
+        latestVersion: latest
+      };
+    } catch (err2) {
+      return {
+        updateAvailable: false,
+        currentVersion: this.config.currentVersion,
+        error: err2 instanceof Error ? err2.message : String(err2)
+      };
+    }
+  }
+  /** Compare two semver strings. 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);
+    for (let i = 0; i < 3; i++) {
+      const va = pa[i] ?? 0;
+      const vb = pb[i] ?? 0;
+      if (va < vb)
+        return -1;
+      if (va > vb)
+        return 1;
+    }
+    return 0;
+  }
+};
+
+// ../core/dist/main.js
 var 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.`;
@@ -2886,6 +3326,7 @@ function resolveLLMClient(config, usage) {
 async function startAgent(configPath) {
   const config = await loadConfig(configPath);
   console.log(`[augure] Loaded config: ${config.identity.name}`);
+  let telegram;
   const llm = resolveLLMClient(config.llm, "default");
   const ingestionLLM = resolveLLMClient(config.llm, "ingestion");
   const monitoringLLM = resolveLLMClient(config.llm, "monitoring");
@@ -2921,6 +3362,7 @@ async function startAgent(configPath) {
   });
   console.log(`[augure] Container pool created (max: ${config.security.maxConcurrentSandboxes})`);
   let skillManagerRef;
+  let skillUpdater;
   if (config.skills) {
     const skillsPath = resolve(configPath, "..", config.skills.path);
     const codingLLM = resolveLLMClient(config.llm, "coding");
@@ -2956,6 +3398,26 @@ async function startAgent(configPath) {
     }
     const skillBridge = new SkillSchedulerBridge(scheduler, skillManager);
     await skillBridge.syncAll();
+    if (hub && config.updates?.skills?.enabled !== false) {
+      skillUpdater = new SkillUpdater({
+        manager: skillManager,
+        hub,
+        tester: skillTester
+      });
+      try {
+        const updateResults = await skillUpdater.checkAndApply();
+        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(", ")}`);
+        }
+        if (failed.length > 0) {
+          console.log(`[augure] Skill updates failed: ${failed.map((r) => `${r.skillId}: ${r.error}`).join(", ")}`);
+        }
+      } catch (err2) {
+        console.error("[augure] Skill update check failed:", err2);
+      }
+    }
     skillManagerRef = skillManager;
     console.log(`[augure] Skills system initialized at ${skillsPath}`);
   }
@@ -2971,6 +3433,19 @@ async function startAgent(configPath) {
     await personaResolver.loadAll();
     console.log(`[augure] Personas loaded from ${personaPath}`);
   }
+  if (config.updates?.cli?.enabled !== false) {
+    const require3 = createRequire(import.meta.url);
+    const { version: version2 } = require3("augure/package.json");
+    const versionChecker = new VersionChecker({
+      currentVersion: version2,
+      packageName: "augure",
+      githubRepo: "FaureAlexis/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`);
+    }
+  }
   const guard = new ContextGuard({
     maxContextTokens: 2e5,
     reservedForOutput: config.llm.default.maxTokens ?? 8192
@@ -2987,22 +3462,24 @@ async function startAgent(configPath) {
     modelName: config.llm.default.model
   });
   if (config.channels.telegram?.enabled) {
-    const telegram = new TelegramChannel({
+    telegram = new TelegramChannel({
       botToken: config.channels.telegram.botToken,
-      allowedUsers: config.channels.telegram.allowedUsers
+      allowedUsers: config.channels.telegram.allowedUsers,
+      rejectMessage: config.channels.telegram.rejectMessage
     });
+    const tg = telegram;
     const commandCtx = {
       scheduler,
       pool,
       agent,
       skillManager: skillManagerRef
     };
-    telegram.onMessage(async (msg) => {
+    tg.onMessage(async (msg) => {
       console.log(`[augure] Message from ${msg.userId}: ${msg.text}`);
       try {
         const cmdResult = await handleCommand(msg.text, commandCtx);
         if (cmdResult.handled) {
-          await telegram.send({
+          await tg.send({
             channelType: "telegram",
             userId: msg.userId,
             text: cmdResult.response ?? "OK",
@@ -3014,7 +3491,7 @@ async function startAgent(configPath) {
           agent.setPersona(personaResolver.resolve(msg.text));
         }
         const response = await agent.handleMessage(msg);
-        await telegram.send({
+        await tg.send({
           channelType: "telegram",
           userId: msg.userId,
           text: response,
@@ -3022,14 +3499,14 @@ async function startAgent(configPath) {
         });
       } catch (err2) {
         console.error("[augure] Error handling message:", err2);
-        await telegram.send({
+        await tg.send({
           channelType: "telegram",
           userId: msg.userId,
           text: "An error occurred while processing your message."
         });
       }
     });
-    await telegram.start();
+    await tg.start();
     console.log("[augure] Telegram bot started. Waiting for messages...");
   }
   const heartbeatIntervalMs = parseInterval(config.scheduler.heartbeatInterval);
@@ -3052,10 +3529,57 @@ async function startAgent(configPath) {
   scheduler.start();
   heartbeat.start();
   console.log(`[augure] Scheduler started with ${scheduler.listJobs().length} jobs. Heartbeat every ${config.scheduler.heartbeatInterval}.`);
+  if (skillUpdater && config.updates?.skills?.checkInterval) {
+    const skillCheckMs = parseInterval(config.updates.skills.checkInterval);
+    setInterval(async () => {
+      try {
+        const results = await skillUpdater.checkAndApply();
+        for (const r of results) {
+          if (r.success) {
+            console.log(`[augure] 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}`);
+          }
+        }
+      } catch (err2) {
+        console.error("[augure] Periodic skill update check failed:", err2);
+      }
+    }, skillCheckMs);
+  }
+  if (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"
+    });
+    setInterval(async () => {
+      try {
+        const result = await versionChecker.check();
+        if (result.updateAvailable && telegram) {
+          const userId = config.channels.telegram?.allowedUsers[0];
+          if (userId !== void 0) {
+            await telegram.send({
+              channelType: "telegram",
+              userId: String(userId),
+              text: `Update available: Augure v${result.latestVersion} (current: v${result.currentVersion}).
+Run: \`npm update -g augure\``
+            });
+          }
+        }
+      } catch (err2) {
+        console.error("[augure] CLI version check failed:", err2);
+      }
+    }, cliCheckMs);
+  }
   const shutdown = async () => {
     console.log("\n[augure] Shutting down...");
     heartbeat.stop();
     scheduler.stop();
+    if (telegram)
+      await telegram.stop();
     await pool.destroyAll();
     await audit.close();
     console.log("[augure] All containers destroyed");
@@ -3087,10 +3611,21 @@ var startCommand = defineCommand({
       description: "Path to config file",
       alias: "c",
       default: "./augure.json5"
+    },
+    env: {
+      type: "string",
+      description: "Path to .env file",
+      alias: "e"
     }
   },
   async run({ args }) {
     const configPath = resolve2(args.config);
+    const envPath = args.env ? resolve2(args.env) : join6(dirname4(configPath), ".env");
+    try {
+      process.loadEnvFile(envPath);
+      console.log(`${prefix} Loaded env from ${dim(envPath)}`);
+    } catch {
+    }
     console.log(`${prefix} Starting with config: ${dim(configPath)}`);
     try {
       await startAgent(configPath);
@@ -3442,7 +3977,7 @@ var skillsCommand = defineCommand3({
 });
 
 // src/bin.ts
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 var { version } = require2("../package.json");
 var main = defineCommand4({
   meta: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "augure",
-  "version": "0.3.0",
+  "version": "0.4.2",
   "description": "Augure — your proactive AI agent",
   "type": "module",
   "bin": {
@@ -12,6 +12,15 @@
   "engines": {
     "node": ">=22.0.0"
   },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:unit": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist .turbo"
+  },
   "dependencies": {
     "citty": "^0.2.1",
     "dockerode": "^4.0.9",
@@ -24,17 +33,17 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@augure/channels": "workspace:*",
+    "@augure/core": "workspace:*",
+    "@augure/memory": "workspace:*",
+    "@augure/sandbox": "workspace:*",
+    "@augure/scheduler": "workspace:*",
+    "@augure/skills": "workspace:*",
+    "@augure/tools": "workspace:*",
+    "@augure/types": "workspace:*",
     "@types/dockerode": "^4.0.1",
     "@types/node-cron": "^3.0.11",
-    "tsup": "^8.5.1",
-    "@augure/channels": "0.0.1",
-    "@augure/memory": "0.0.1",
-    "@augure/sandbox": "0.0.1",
-    "@augure/core": "0.0.1",
-    "@augure/scheduler": "0.0.1",
-    "@augure/skills": "0.0.1",
-    "@augure/types": "0.0.1",
-    "@augure/tools": "0.0.1"
+    "tsup": "^8.5.1"
   },
   "keywords": [
     "ai",
@@ -52,14 +61,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:unit": "vitest run",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src/",
-    "clean": "rm -rf dist .turbo"
   }
-}
+}