augure 0.4.0 → 0.5.0

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/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
@@ -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({
@@ -198,11 +201,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
@@ -578,62 +585,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) {
@@ -712,7 +663,8 @@ function createSplitMessageMiddleware(sendFn, maxLength = TELEGRAM_MAX) {
 // ../channels/dist/middleware/error-handler.js
 function isRetryable(error) {
   if (error instanceof Error) {
-    const status = error.status;
+    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)
@@ -738,6 +690,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) => {
@@ -827,23 +811,20 @@ 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) => {
+        await this.bot.api.sendMessage(Number(msg.userId), msg.text, replyOpts).catch((fallbackErr) => {
           console.error("[augure:telegram] 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);
@@ -962,7 +943,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: {
@@ -972,13 +953,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": {
@@ -986,22 +968,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) {
@@ -1660,6 +1649,63 @@ 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) {
+  try {
+    await docker.getImage(imageName).inspect();
+    return;
+  } catch (err2) {
+    const statusCode = err2.statusCode;
+    if (statusCode !== void 0 && statusCode !== 404)
+      throw err2;
+  }
+  console.log(`[augure] 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)
+        process.stdout.write(event.stream);
+    });
+  });
+  console.log(`[augure] Image "${imageName}" built successfully`);
+}
+
 // ../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";
@@ -1823,6 +1869,7 @@ var CronScheduler = class {
   store;
   jobs = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
   handlers = [];
   persistChain = Promise.resolve();
   constructor(store) {
@@ -1832,11 +1879,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);
       });
@@ -1850,6 +1903,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();
   }
@@ -1868,6 +1926,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);
     }
   }
@@ -1875,11 +1936,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)
@@ -3163,8 +3245,162 @@ 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;
+    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);
+      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 (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 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;
+      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.`;
@@ -3179,7 +3415,7 @@ function resolveLLMClient(config, usage) {
 async function startAgent(configPath) {
   const config = await loadConfig(configPath);
   console.log(`[augure] Loaded config: ${config.identity.name}`);
-  let telegramChannel;
+  let telegram;
   const llm = resolveLLMClient(config.llm, "default");
   const ingestionLLM = resolveLLMClient(config.llm, "ingestion");
   const monitoringLLM = resolveLLMClient(config.llm, "monitoring");
@@ -3209,12 +3445,15 @@ async function startAgent(configPath) {
     }
   }
   const docker = new Dockerode();
+  const sandboxImage = config.sandbox.image ?? "augure-sandbox:latest";
+  await ensureImage(docker, sandboxImage);
   const pool = new DockerContainerPool(docker, {
-    image: config.sandbox.image ?? "augure-sandbox:latest",
+    image: sandboxImage,
     maxTotal: config.security.maxConcurrentSandboxes
   });
   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");
@@ -3250,6 +3489,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}`);
   }
@@ -3265,6 +3524,23 @@ async function startAgent(configPath) {
     await personaResolver.loadAll();
     console.log(`[augure] Personas loaded from ${personaPath}`);
   }
+  let cliVersion;
+  try {
+    const require3 = createRequire(import.meta.url);
+    const pkg = require3("augure/package.json");
+    cliVersion = pkg.version;
+  } catch {
+  }
+  if (cliVersion && config.updates?.cli?.enabled !== false) {
+    const versionChecker = new VersionChecker({
+      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`);
+    }
+  }
   const guard = new ContextGuard({
     maxContextTokens: 2e5,
     reservedForOutput: config.llm.default.maxTokens ?? 8192
@@ -3281,23 +3557,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,
       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",
@@ -3309,7 +3586,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,
@@ -3317,15 +3594,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();
-    telegramChannel = telegram;
+    await tg.start();
     console.log("[augure] Telegram bot started. Waiting for messages...");
   }
   const heartbeatIntervalMs = parseInterval(config.scheduler.heartbeatInterval);
@@ -3345,15 +3621,82 @@ async function startAgent(configPath) {
       console.log(`[augure] Heartbeat response: ${response}`);
     }
   });
+  scheduler.onJobTrigger(async (job) => {
+    console.log(`[augure] 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
+        });
+      }
+    }
+    console.log(`[augure] Job ${job.id} completed`);
+  });
   scheduler.start();
   heartbeat.start();
   console.log(`[augure] Scheduler started with ${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);
+    updateTimers.push(setInterval(async () => {
+      try {
+        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}`);
+          } 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 (cliVersion && config.updates?.cli?.enabled !== false && config.channels.telegram?.enabled) {
+    const cliCheckMs = parseInterval(config.updates?.cli?.checkInterval ?? "24h");
+    const versionChecker = new VersionChecker({
+      currentVersion: cliVersion,
+      packageName: "augure"
+    });
+    updateTimers.push(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...");
+    for (const timer of updateTimers)
+      clearInterval(timer);
     heartbeat.stop();
     scheduler.stop();
-    if (telegramChannel)
-      await telegramChannel.stop();
+    if (telegram)
+      await telegram.stop();
     await pool.destroyAll();
     await audit.close();
     console.log("[augure] All containers destroyed");
@@ -3751,7 +4094,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.4.0",
+  "version": "0.5.0",
   "description": "Augure — your proactive AI agent",
   "type": "module",
   "bin": {
@@ -27,14 +27,14 @@
     "@types/dockerode": "^4.0.1",
     "@types/node-cron": "^3.0.11",
     "tsup": "^8.5.1",
-    "@augure/core": "0.1.0",
-    "@augure/memory": "0.0.2",
-    "@augure/sandbox": "0.0.2",
-    "@augure/channels": "0.1.0",
-    "@augure/scheduler": "0.0.2",
-    "@augure/tools": "0.0.2",
-    "@augure/types": "0.1.0",
-    "@augure/skills": "0.1.0"
+    "@augure/channels": "0.1.1",
+    "@augure/core": "0.2.0",
+    "@augure/memory": "0.0.3",
+    "@augure/sandbox": "0.1.0",
+    "@augure/scheduler": "0.1.0",
+    "@augure/skills": "0.1.1",
+    "@augure/types": "0.1.1",
+    "@augure/tools": "0.0.3"
   },
   "keywords": [
     "ai",