augure 0.2.0 → 0.3.0

package/dist/bin.js

@@ -1,22 +1,3459 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-import { defineCommand, runMain } from "citty";
-import { startCommand } from "./commands/start.js";
-import { initCommand } from "./commands/init.js";
-import { skillsCommand } from "./commands/skills.js";
-const require = createRequire(import.meta.url);
-const { version } = require("../package.json");
-const main = defineCommand({
-    meta: {
-        name: "augure",
-        description: "Augure — your proactive AI agent",
-        version,
-    },
-    subCommands: {
-        start: startCommand,
-        init: initCommand,
-        skills: skillsCommand,
+
+// src/bin.ts
+import { createRequire } from "module";
+import { defineCommand as defineCommand4, runMain } from "citty";
+
+// src/commands/start.ts
+import { defineCommand } from "citty";
+import { resolve as resolve2 } from "path";
+
+// ../core/dist/config.js
+import { readFile } from "fs/promises";
+import JSON5 from "json5";
+import { z } from "zod";
+var LLMModelConfigSchema = z.object({
+  provider: z.enum(["openrouter", "anthropic", "openai"]),
+  apiKey: z.string().min(1),
+  model: z.string().min(1),
+  maxTokens: z.number().int().positive()
+});
+var LLMConfigSchema = z.object({
+  default: LLMModelConfigSchema,
+  reasoning: LLMModelConfigSchema.partial().optional(),
+  ingestion: LLMModelConfigSchema.partial().optional(),
+  monitoring: LLMModelConfigSchema.partial().optional(),
+  coding: LLMModelConfigSchema.partial().optional()
+});
+var AppConfigSchema = z.object({
+  identity: z.object({
+    name: z.string().min(1),
+    personality: z.string().min(1)
+  }),
+  llm: LLMConfigSchema,
+  channels: z.object({
+    telegram: z.object({
+      enabled: z.boolean(),
+      botToken: z.string(),
+      allowedUsers: z.array(z.number())
+    }).optional(),
+    whatsapp: z.object({ enabled: z.boolean() }).optional(),
+    web: z.object({ enabled: z.boolean(), port: z.number() }).optional()
+  }),
+  memory: z.object({
+    path: z.string().min(1),
+    autoIngest: z.boolean(),
+    maxRetrievalTokens: z.number().int().positive()
+  }),
+  scheduler: z.object({
+    heartbeatInterval: z.string().min(1),
+    jobs: z.array(z.object({
+      id: z.string().min(1),
+      cron: z.string().min(1),
+      prompt: z.string().min(1),
+      channel: z.string().min(1)
+    }))
+  }),
+  sandbox: z.object({
+    runtime: z.literal("docker"),
+    image: z.string().min(1).optional(),
+    defaults: z.object({
+      timeout: z.number().int().positive(),
+      memoryLimit: z.string().min(1),
+      cpuLimit: z.string().min(1)
+    }),
+    codeAgent: z.object({
+      command: z.string().min(1),
+      args: z.array(z.string()).optional(),
+      env: z.record(z.string(), z.string()).optional()
+    }).optional()
+  }),
+  tools: z.object({
+    webSearch: z.object({
+      provider: z.enum(["tavily", "exa", "searxng"]),
+      apiKey: z.string().optional(),
+      baseUrl: z.string().optional(),
+      maxResults: z.number().int().positive().optional()
+    }).optional(),
+    http: z.object({
+      defaultHeaders: z.record(z.string(), z.string()).optional(),
+      presets: z.record(z.string(), z.object({
+        baseUrl: z.string(),
+        headers: z.record(z.string(), z.string())
+      })).optional(),
+      timeoutMs: z.number().int().positive().optional(),
+      maxResponseBytes: z.number().int().positive().optional()
+    }).optional(),
+    email: z.object({
+      imap: z.object({
+        host: z.string(),
+        port: z.number(),
+        user: z.string(),
+        password: z.string()
+      }),
+      smtp: z.object({
+        host: z.string(),
+        port: z.number(),
+        user: z.string(),
+        password: z.string()
+      })
+    }).optional(),
+    github: z.object({ token: z.string() }).optional()
+  }),
+  security: z.object({
+    sandboxOnly: z.boolean(),
+    allowedHosts: z.array(z.string()),
+    maxConcurrentSandboxes: z.number().int().positive()
+  }),
+  skills: z.object({
+    path: z.string().min(1).default("./skills"),
+    maxFailures: z.number().int().positive().default(3),
+    autoSuggest: z.boolean().default(true),
+    hub: z.object({
+      repo: z.string().min(1),
+      branch: z.string().min(1).default("main")
+    }).optional()
+  }).optional(),
+  audit: z.object({
+    path: z.string().min(1).default("./logs"),
+    enabled: z.boolean().default(true)
+  }).optional(),
+  persona: z.object({
+    path: z.string().min(1).default("./config/personas")
+  }).optional()
+});
+function interpolateEnvVars(raw) {
+  return raw.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+    const value = process.env[varName];
+    if (value === void 0) {
+      throw new Error(`Missing environment variable: ${varName}`);
+    }
+    return value;
+  });
+}
+async function loadConfig(path) {
+  const raw = await readFile(path, "utf-8");
+  const interpolated = interpolateEnvVars(raw);
+  const parsed = JSON5.parse(interpolated);
+  return AppConfigSchema.parse(parsed);
+}
+
+// ../core/dist/llm.js
+var OpenRouterClient = class {
+  apiKey;
+  model;
+  maxTokens;
+  baseUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.model = config.model;
+    this.maxTokens = config.maxTokens;
+    this.baseUrl = config.baseUrl ?? "https://openrouter.ai/api/v1";
+  }
+  async chat(messages) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: this.maxTokens,
+        messages: messages.map((m) => ({
+          role: m.role,
+          content: m.content,
+          ...m.toolCallId ? { tool_call_id: m.toolCallId } : {}
+        }))
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`OpenRouter API error ${response.status}: ${body}`);
+    }
+    const data = await response.json();
+    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)
+      })),
+      usage: {
+        inputTokens: data.usage.prompt_tokens,
+        outputTokens: data.usage.completion_tokens
+      }
+    };
+  }
+};
+
+// ../core/dist/context.js
+function assembleContext(input) {
+  const { systemPrompt, memoryContent, toolSchemas, conversationHistory, persona } = input;
+  let system = systemPrompt;
+  if (persona) {
+    system += `
+
+## Active Persona
+${persona}`;
+  }
+  if (memoryContent) {
+    system += `
+
+## 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);
+  return messages;
+}
+
+// ../core/dist/audit.js
+import { appendFile, mkdir } from "fs/promises";
+import { join } from "path";
+function summarize(text, maxLen = 200) {
+  if (text.length <= maxLen)
+    return text;
+  return text.slice(0, maxLen) + "...";
+}
+var FileAuditLogger = class {
+  basePath;
+  pendingWrite = Promise.resolve();
+  initialized = false;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  log(entry) {
+    this.pendingWrite = this.pendingWrite.then(() => this.writeEntry(entry)).catch((err2) => console.error("[augure] Audit write error:", err2));
+  }
+  async close() {
+    await this.pendingWrite;
+  }
+  async writeEntry(entry) {
+    const dir = join(this.basePath, "actions");
+    if (!this.initialized) {
+      await mkdir(dir, { recursive: true });
+      this.initialized = true;
+    }
+    const date = entry.ts.slice(0, 10);
+    const filePath = join(dir, `${date}.jsonl`);
+    await appendFile(filePath, JSON.stringify(entry) + "\n");
+  }
+};
+var NullAuditLogger = class {
+  log(_entry) {
+  }
+  async close() {
+  }
+};
+
+// ../core/dist/agent.js
+var Agent = class {
+  config;
+  conversationHistory = [];
+  state = "running";
+  constructor(config) {
+    this.config = config;
+  }
+  getState() {
+    return this.state;
+  }
+  setState(s) {
+    this.state = s;
+  }
+  setPersona(text) {
+    this.config.persona = text;
+  }
+  async handleMessage(incoming) {
+    if (this.state === "killed") {
+      return "Agent is in emergency stop mode. Send /resume to reactivate.";
+    }
+    const start = Date.now();
+    this.conversationHistory.push({
+      role: "user",
+      content: incoming.text
+    });
+    if (this.config.guard) {
+      this.conversationHistory = this.config.guard.compact(this.conversationHistory);
+    }
+    let memoryContent = this.config.memoryContent;
+    if (this.config.retriever) {
+      memoryContent = await this.config.retriever.retrieve();
+    }
+    const maxLoops = this.config.maxToolLoops ?? 10;
+    let loopCount = 0;
+    while (loopCount < maxLoops) {
+      const messages = assembleContext({
+        systemPrompt: this.config.systemPrompt,
+        memoryContent,
+        toolSchemas: this.config.tools.toFunctionSchemas(),
+        conversationHistory: this.conversationHistory,
+        persona: this.config.persona
+      });
+      const response = await this.config.llm.chat(messages);
+      if (response.toolCalls.length === 0) {
+        this.conversationHistory.push({
+          role: "assistant",
+          content: response.content
+        });
+        if (this.config.audit) {
+          this.config.audit.log({
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            trigger: incoming.channelType === "system" ? "heartbeat" : "user",
+            action: "chat",
+            inputSummary: summarize(incoming.text),
+            outputSummary: summarize(response.content),
+            tokens: {
+              input: response.usage.inputTokens,
+              output: response.usage.outputTokens,
+              model: this.config.modelName ?? ""
+            },
+            durationMs: Date.now() - start,
+            success: true
+          });
+        }
+        if (this.config.ingester) {
+          this.config.ingester.ingest(this.conversationHistory).catch((err2) => console.error("[augure] Ingestion error:", err2));
+        }
+        return response.content;
+      }
+      this.conversationHistory.push({
+        role: "assistant",
+        content: response.content || ""
+      });
+      for (const toolCall of response.toolCalls) {
+        const toolStart = Date.now();
+        const result = await this.config.tools.execute(toolCall.name, toolCall.arguments);
+        this.conversationHistory.push({
+          role: "tool",
+          content: result.output,
+          toolCallId: toolCall.id
+        });
+        if (this.config.audit) {
+          this.config.audit.log({
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            trigger: incoming.channelType === "system" ? "heartbeat" : "user",
+            action: toolCall.name,
+            inputSummary: summarize(JSON.stringify(toolCall.arguments)),
+            outputSummary: summarize(result.output),
+            durationMs: Date.now() - toolStart,
+            success: result.success,
+            error: result.success ? void 0 : result.output
+          });
+        }
+      }
+      loopCount++;
+    }
+    return "Max tool call loops reached. Please try again.";
+  }
+  getConversationHistory() {
+    return [...this.conversationHistory];
+  }
+  clearHistory() {
+    this.conversationHistory = [];
+  }
+};
+
+// ../core/dist/commands.js
+async function handleCommand(text, ctx) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/")) {
+    return { handled: false };
+  }
+  const parts = trimmed.slice(1).split(/\s+/);
+  const command = parts[0]?.toLowerCase();
+  const arg = parts[1];
+  switch (command) {
+    case "pause": {
+      if (arg) {
+        if (!ctx.skillManager) {
+          return { handled: true, response: "Skills system is not configured." };
+        }
+        await ctx.skillManager.updateStatus(arg, "paused");
+        return { handled: true, response: `Skill "${arg}" paused.` };
+      }
+      ctx.scheduler.stop();
+      ctx.agent.setState("paused");
+      return { handled: true, response: "Agent paused. Scheduler stopped. Direct messages still accepted." };
+    }
+    case "resume": {
+      ctx.scheduler.start();
+      ctx.agent.setState("running");
+      return { handled: true, response: "Agent resumed. Scheduler restarted." };
+    }
+    case "kill": {
+      ctx.scheduler.stop();
+      await ctx.pool.destroyAll();
+      ctx.agent.setState("killed");
+      return { handled: true, response: "Emergency stop. All containers destroyed. Agent in read-only mode." };
+    }
+    case "status": {
+      const state = ctx.agent.getState();
+      return { handled: true, response: `Agent state: ${state}` };
+    }
+    default:
+      return { handled: false };
+  }
+}
+
+// ../core/dist/persona.js
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import matter from "gray-matter";
+var PersonaResolver = class {
+  personaDir;
+  personas = [];
+  constructor(personaDir) {
+    this.personaDir = personaDir;
+  }
+  async loadAll() {
+    this.personas = [];
+    let entries;
+    try {
+      entries = await readdir(this.personaDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".md"))
+        continue;
+      const content = await readFile2(join2(this.personaDir, entry), "utf-8");
+      const { data, content: body } = matter(content);
+      const meta = {
+        id: data.id ?? entry.replace(".md", ""),
+        name: data.name ?? entry.replace(".md", ""),
+        triggers: data.triggers,
+        priority: data.priority ?? 0
+      };
+      this.personas.push({ meta, body: body.trim() });
+    }
+    this.personas.sort((a, b) => a.meta.id.localeCompare(b.meta.id));
+  }
+  resolve(message, activeSkillId) {
+    const defaultPersona = this.personas.find((p) => p.meta.id === "default");
+    const baseParts = [];
+    if (defaultPersona) {
+      baseParts.push(defaultPersona.body);
+    }
+    let bestMatch;
+    let bestScore = 0;
+    const lowerMessage = message.toLowerCase();
+    for (const persona of this.personas) {
+      if (persona.meta.id === "default")
+        continue;
+      let score = 0;
+      if (persona.meta.triggers?.keywords) {
+        for (const kw of persona.meta.triggers.keywords) {
+          if (lowerMessage.includes(kw.toLowerCase())) {
+            score++;
+          }
+        }
+      }
+      if (activeSkillId && persona.meta.triggers?.skills) {
+        for (const pattern of persona.meta.triggers.skills) {
+          if (matchGlob(pattern, activeSkillId)) {
+            score += 2;
+          }
+        }
+      }
+      if (score === 0)
+        continue;
+      const priority = persona.meta.priority ?? 0;
+      const finalScore = score + priority;
+      if (finalScore > bestScore) {
+        bestScore = finalScore;
+        bestMatch = persona;
+      }
+    }
+    if (bestMatch) {
+      baseParts.push(bestMatch.body);
+    }
+    return baseParts.join("\n\n");
+  }
+};
+function matchGlob(pattern, value) {
+  if (pattern.endsWith("*")) {
+    return value.startsWith(pattern.slice(0, -1));
+  }
+  return pattern === value;
+}
+
+// ../core/dist/context-guard.js
+var DEFAULT_CONFIG = {
+  maxContextTokens: 2e5,
+  reservedForOutput: 8192,
+  maxConversationTurns: 50
+};
+var ContextGuard = class {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  compact(messages) {
+    let result = [...messages];
+    if (result.length > this.config.maxConversationTurns) {
+      result = result.slice(-this.config.maxConversationTurns);
+    }
+    const recentToolCutoff = Math.max(0, result.length - 10);
+    result = result.map((msg, i) => {
+      if (msg.role === "tool" && i < recentToolCutoff) {
+        return { ...msg, content: "[Tool result truncated]" };
+      }
+      return msg;
+    });
+    result = result.map((msg) => {
+      if (msg.role === "tool" && msg.content.length > 2e3) {
+        return { ...msg, content: msg.content.slice(0, 2e3) + "... [truncated]" };
+      }
+      return msg;
+    });
+    const budget = this.config.maxContextTokens - this.config.reservedForOutput;
+    let totalTokens = result.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
+    while (totalTokens > budget && result.length > 1) {
+      const removed = result.shift();
+      totalTokens -= this.estimateTokens(removed.content);
+    }
+    return result;
+  }
+};
+
+// ../channels/dist/telegram.js
+import { Bot } from "grammy";
+var TelegramChannel = class {
+  type = "telegram";
+  bot;
+  allowedUsers;
+  handlers = [];
+  constructor(config) {
+    this.bot = new Bot(config.botToken);
+    this.allowedUsers = new Set(config.allowedUsers);
+    this.bot.on("message:text", async (ctx) => {
+      const userId = ctx.from.id;
+      if (!this.isUserAllowed(userId)) {
+        return;
+      }
+      const incoming = {
+        id: String(ctx.message.message_id),
+        channelType: "telegram",
+        userId: String(userId),
+        text: ctx.message.text,
+        timestamp: new Date(ctx.message.date * 1e3),
+        replyTo: ctx.message.reply_to_message ? String(ctx.message.reply_to_message.message_id) : void 0
+      };
+      for (const handler of this.handlers) {
+        await handler(incoming);
+      }
+    });
+  }
+  isUserAllowed(userId) {
+    return this.allowedUsers.has(userId);
+  }
+  onMessage(handler) {
+    this.handlers.push(handler);
+  }
+  async start() {
+    await this.bot.start();
+  }
+  async stop() {
+    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) } } : {}
+    });
+  }
+};
+
+// ../tools/dist/registry.js
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  context;
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  toFunctionSchemas() {
+    return this.list().map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    }));
+  }
+  async execute(name, params) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool not found: ${name}`);
+    }
+    return tool.execute(params, this.context);
+  }
+  setContext(ctx) {
+    this.context = ctx;
+  }
+};
+
+// ../tools/dist/memory.js
+var memoryReadTool = {
+  name: "memory_read",
+  description: "Read content from memory. If path is provided, reads that file. If path is omitted, lists all memory files.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The memory file path to read (omit to list all files)"
+      }
+    }
+  },
+  execute: async (params, ctx) => {
+    const { path } = params;
+    try {
+      if (!path) {
+        const files = await ctx.memory.list();
+        return { success: true, output: files.join("\n") };
+      }
+      const content = await ctx.memory.read(path);
+      return { success: true, output: content };
+    } catch (err2) {
+      return {
+        success: false,
+        output: err2 instanceof Error ? err2.message : String(err2)
+      };
+    }
+  }
+};
+var memoryWriteTool = {
+  name: "memory_write",
+  description: "Write content to a memory file at the given path",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "The memory file path to write to" },
+      content: { type: "string", description: "The content to write" }
+    },
+    required: ["path", "content"]
+  },
+  execute: async (params, ctx) => {
+    const { path, content } = params;
+    try {
+      await ctx.memory.write(path, content);
+      return { success: true, output: `Written to ${path}` };
+    } catch (err2) {
+      return {
+        success: false,
+        output: err2 instanceof Error ? err2.message : String(err2)
+      };
+    }
+  }
+};
+
+// ../tools/dist/schedule.js
+var scheduleTool = {
+  name: "schedule",
+  description: "Manage scheduled tasks: create, delete, or list cron jobs",
+  parameters: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["create", "delete", "list"],
+        description: "The scheduling action to perform"
+      },
+      id: { type: "string", description: "The schedule ID (for create/delete)" },
+      cron: { type: "string", description: "Cron expression (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;
+    try {
+      switch (action) {
+        case "list": {
+          const jobs = ctx.scheduler.listJobs();
+          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"})`);
+          return { success: true, output: lines.join("\n") };
+        }
+        case "create": {
+          if (!cron || !prompt) {
+            return { success: false, output: "Missing required fields: cron and prompt" };
+          }
+          const jobId = id ?? `job-${Date.now()}`;
+          ctx.scheduler.addJob({
+            id: jobId,
+            cron,
+            prompt,
+            channel: "default",
+            enabled: true
+          });
+          return { success: true, output: `Created job ${jobId}` };
+        }
+        case "delete": {
+          if (!id) {
+            return { success: false, output: "Missing required field: id" };
+          }
+          ctx.scheduler.removeJob(id);
+          return { success: true, output: `Deleted job ${id}` };
+        }
+        default:
+          return { success: false, output: `Unknown action: ${action}` };
+      }
+    } catch (err2) {
+      return {
+        success: false,
+        output: err2 instanceof Error ? err2.message : String(err2)
+      };
+    }
+  }
+};
+
+// ../tools/dist/web-search.js
+var webSearchTool = {
+  name: "web_search",
+  description: "Search the web using the configured search provider (Tavily, Exa, or SearXNG)",
+  parameters: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "The search query" },
+      maxResults: {
+        type: "number",
+        description: "Max results (default: from config or 5)"
+      }
+    },
+    required: ["query"]
+  },
+  execute: async (params, ctx) => {
+    const { query, maxResults: maxResultsParam } = params;
+    const cfg = ctx.config.tools?.webSearch;
+    if (!cfg) {
+      return {
+        success: false,
+        output: "web_search is not configured. Set tools.webSearch in your config."
+      };
+    }
+    const maxResults = maxResultsParam ?? cfg.maxResults ?? 5;
+    try {
+      let results;
+      switch (cfg.provider) {
+        case "tavily":
+          if (!cfg.apiKey) {
+            return { success: false, output: "Tavily requires tools.webSearch.apiKey in config." };
+          }
+          results = await searchTavily(query, maxResults, cfg.apiKey);
+          break;
+        case "exa":
+          if (!cfg.apiKey) {
+            return { success: false, output: "Exa requires tools.webSearch.apiKey in config." };
+          }
+          results = await searchExa(query, maxResults, cfg.apiKey);
+          break;
+        case "searxng":
+          if (!cfg.baseUrl) {
+            return { success: false, output: "SearXNG requires tools.webSearch.baseUrl in config." };
+          }
+          results = await searchSearXNG(query, maxResults, cfg.baseUrl);
+          break;
+        default:
+          return {
+            success: false,
+            output: `Unknown search provider: ${cfg.provider}`
+          };
+      }
+      if (results.length === 0) {
+        return { success: true, output: "No results found." };
+      }
+      const formatted = results.map((r, i) => `${i + 1}. **${r.title}**
+   ${r.snippet}
+   ${r.url}`).join("\n\n");
+      return { success: true, output: formatted };
+    } catch (err2) {
+      return {
+        success: false,
+        output: err2 instanceof Error ? err2.message : String(err2)
+      };
+    }
+  }
+};
+async function searchTavily(query, maxResults, apiKey) {
+  const res = await fetch("https://api.tavily.com/search", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ query, max_results: maxResults })
+  });
+  if (!res.ok) {
+    throw new Error(`Tavily API error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  return data.results.map((r) => ({
+    title: r.title,
+    url: r.url,
+    snippet: r.content
+  }));
+}
+async function searchExa(query, maxResults, apiKey) {
+  const res = await fetch("https://api.exa.ai/search", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query,
+      numResults: maxResults,
+      contents: { text: { maxCharacters: 300 } }
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`Exa API error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  return data.results.map((r) => ({
+    title: r.title,
+    url: r.url,
+    snippet: r.text
+  }));
+}
+async function searchSearXNG(query, maxResults, baseUrl) {
+  const url = new URL("/search", baseUrl);
+  url.searchParams.set("q", query);
+  url.searchParams.set("format", "json");
+  url.searchParams.set("pageno", "1");
+  const res = await fetch(url.toString(), {
+    method: "GET",
+    headers: { Accept: "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`SearXNG API error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  return data.results.slice(0, maxResults).map((r) => ({
+    title: r.title,
+    url: r.url,
+    snippet: r.content
+  }));
+}
+
+// ../tools/dist/http.js
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_RESPONSE_BYTES = 1048576;
+var MAX_OUTPUT_CHARS = 4e3;
+var httpTool = {
+  name: "http",
+  description: "Make HTTP requests (GET or POST). Use a preset name to inject auth headers from config.",
+  parameters: {
+    type: "object",
+    properties: {
+      method: { type: "string", enum: ["GET", "POST"], description: "HTTP method" },
+      url: { type: "string", description: "Full URL, or path if using a preset" },
+      preset: { type: "string", description: "Config preset name for auth injection" },
+      body: { type: "object", description: "JSON body (POST only)" },
+      headers: { type: "object", description: "Additional headers (no auth \u2014 use preset)" }
+    },
+    required: ["method", "url"]
+  },
+  execute: async (params, ctx) => {
+    const { method, url, preset, body, headers: extraHeaders } = params;
+    if (method !== "GET" && method !== "POST") {
+      return { success: false, output: "Only GET or POST methods are allowed" };
+    }
+    const httpConfig = ctx.config.tools?.http;
+    let resolvedUrl = url;
+    let presetHeaders = {};
+    if (preset) {
+      const presetConfig = httpConfig?.presets?.[preset];
+      if (!presetConfig) {
+        return {
+          success: false,
+          output: `Unknown preset: "${preset}". Check your config.`
+        };
+      }
+      if (!url.startsWith("http")) {
+        resolvedUrl = presetConfig.baseUrl + url;
+      }
+      presetHeaders = presetConfig.headers ?? {};
+    }
+    const mergedHeaders = {
+      ...httpConfig?.defaultHeaders ?? {},
+      ...extraHeaders ?? {},
+      ...presetHeaders
+    };
+    if (body) {
+      mergedHeaders["Content-Type"] = "application/json";
+    }
+    const timeoutMs = httpConfig?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxBytes = httpConfig?.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetch(resolvedUrl, {
+        method,
+        headers: mergedHeaders,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      const raw = await res.arrayBuffer();
+      let text = new TextDecoder().decode(raw.slice(0, maxBytes));
+      if (raw.byteLength > maxBytes) {
+        text += "\n[response truncated at byte limit]";
+      }
+      if (text.length > MAX_OUTPUT_CHARS) {
+        text = text.slice(0, MAX_OUTPUT_CHARS) + "\n[truncated]";
+      }
+      const contentType = res.headers.get("content-type") ?? "";
+      const output = `Status: ${res.status} ${res.statusText}
+Content-Type: ${contentType}
+
+${text}`;
+      return { success: res.ok, output };
+    } catch (err2) {
+      return {
+        success: false,
+        output: err2 instanceof Error ? err2.message : String(err2)
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// ../tools/dist/email.js
+import { ImapFlow } from "imapflow";
+import { createTransport } from "nodemailer";
+
+// ../tools/dist/sandbox-exec.js
+var sandboxExecTool = {
+  name: "sandbox_exec",
+  description: "Execute a shell command in an isolated Docker container. Returns stdout, stderr, and exit code.",
+  parameters: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "The shell command to execute"
+      },
+      trust: {
+        type: "string",
+        enum: ["sandboxed", "trusted"],
+        description: "Trust level (default: sandboxed). 'sandboxed' has no network. 'trusted' has host network."
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in seconds (default: from config)"
+      }
+    },
+    required: ["command"]
+  },
+  execute: async (params, ctx) => {
+    const { command, trust, timeout } = params;
+    if (!ctx.pool) {
+      return { success: false, output: "Sandbox pool is not available" };
+    }
+    const defaults = ctx.config.sandbox.defaults;
+    const effectiveTimeout = timeout ?? defaults.timeout;
+    let container;
+    try {
+      container = await ctx.pool.acquire({
+        trust: trust ?? "sandboxed",
+        timeout: effectiveTimeout,
+        memory: defaults.memoryLimit,
+        cpu: defaults.cpuLimit
+      });
+    } catch (err2) {
+      return {
+        success: false,
+        output: `Failed to acquire container: ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+    try {
+      const result = await container.exec(command, {
+        timeout: effectiveTimeout
+      });
+      const parts = [];
+      if (result.stdout)
+        parts.push(result.stdout);
+      if (result.stderr)
+        parts.push(`[stderr]
+${result.stderr}`);
+      parts.push(`Exit code: ${result.exitCode}`);
+      return {
+        success: result.exitCode === 0,
+        output: parts.join("\n")
+      };
+    } catch (err2) {
+      return {
+        success: false,
+        output: err2 instanceof Error ? err2.message : String(err2)
+      };
+    } finally {
+      await ctx.pool.release(container);
+    }
+  }
+};
+
+// ../tools/dist/opencode.js
+function shellEscape(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+var opencodeTool = {
+  name: "opencode",
+  description: "Run a code agent (claude-code, opencode, codex CLI) in a Docker container to perform a coding task.",
+  parameters: {
+    type: "object",
+    properties: {
+      task: {
+        type: "string",
+        description: "Natural language task description for the code agent"
+      },
+      trust: {
+        type: "string",
+        enum: ["sandboxed", "trusted"],
+        description: "Trust level (default: trusted)"
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in seconds (default: from config)"
+      }
+    },
+    required: ["task"]
+  },
+  execute: async (params, ctx) => {
+    const { task, trust, timeout } = params;
+    if (!ctx.pool) {
+      return { success: false, output: "Sandbox pool is not available" };
+    }
+    const agentConfig = ctx.config.sandbox.codeAgent;
+    if (!agentConfig) {
+      return {
+        success: false,
+        output: "codeAgent is not configured in sandbox config"
+      };
+    }
+    const defaults = ctx.config.sandbox.defaults;
+    const effectiveTimeout = timeout ?? defaults.timeout;
+    let container;
+    try {
+      container = await ctx.pool.acquire({
+        trust: trust ?? "trusted",
+        timeout: effectiveTimeout,
+        memory: defaults.memoryLimit,
+        cpu: defaults.cpuLimit
+      });
+    } catch (err2) {
+      return {
+        success: false,
+        output: `Failed to acquire container: ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+    try {
+      const cmdParts = [agentConfig.command];
+      if (agentConfig.args)
+        cmdParts.push(...agentConfig.args);
+      cmdParts.push(shellEscape(task));
+      const command = cmdParts.join(" ");
+      const result = await container.exec(command, {
+        timeout: effectiveTimeout,
+        env: agentConfig.env
+      });
+      const parts = [];
+      if (result.stdout)
+        parts.push(result.stdout);
+      if (result.stderr)
+        parts.push(`[stderr]
+${result.stderr}`);
+      parts.push(`Exit code: ${result.exitCode}`);
+      return {
+        success: result.exitCode === 0,
+        output: parts.join("\n")
+      };
+    } catch (err2) {
+      return {
+        success: false,
+        output: err2 instanceof Error ? err2.message : String(err2)
+      };
+    } finally {
+      await ctx.pool.release(container);
+    }
+  }
+};
+
+// ../core/dist/main.js
+import Dockerode from "dockerode";
+
+// ../sandbox/dist/container.js
+import { PassThrough } from "stream";
+var MAX_OUTPUT_BYTES = 1024 * 1024;
+var DockerContainer = class {
+  id;
+  _status = "idle";
+  raw;
+  demux;
+  constructor(raw, demux) {
+    this.raw = raw;
+    this.id = raw.id;
+    this.demux = demux;
+  }
+  get status() {
+    return this._status;
+  }
+  async exec(command, opts) {
+    this._status = "busy";
+    try {
+      return await this._exec(command, opts);
+    } finally {
+      if (this._status !== "stopped") {
+        this._status = "idle";
+      }
+    }
+  }
+  async stop() {
+    if (this._status === "stopped")
+      return;
+    try {
+      await this.raw.stop({ t: 5 });
+    } catch {
+    }
+    try {
+      await this.raw.remove({ force: true });
+    } catch {
+    }
+    this._status = "stopped";
+  }
+  /* ------------------------------------------------------------------ */
+  async _exec(command, opts) {
+    const createOpts = {
+      Cmd: ["sh", "-c", command],
+      AttachStdout: true,
+      AttachStderr: true
+    };
+    if (opts?.cwd) {
+      createOpts.WorkingDir = opts.cwd;
+    }
+    if (opts?.env) {
+      createOpts.Env = Object.entries(opts.env).map(([k, v]) => `${k}=${v}`);
+    }
+    const exec = await this.raw.exec(createOpts);
+    const stream = await exec.start({ hijack: true, stdin: false });
+    return new Promise((resolve5, reject) => {
+      const stdoutPT = new PassThrough();
+      const stderrPT = new PassThrough();
+      const stdoutBufs = [];
+      const stderrBufs = [];
+      let stdoutLen = 0;
+      let stderrLen = 0;
+      stdoutPT.on("data", (chunk) => {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        const remaining = MAX_OUTPUT_BYTES - stdoutLen;
+        if (remaining > 0) {
+          stdoutBufs.push(buf.subarray(0, remaining));
+          stdoutLen += Math.min(buf.length, remaining);
+        }
+      });
+      stderrPT.on("data", (chunk) => {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        const remaining = MAX_OUTPUT_BYTES - stderrLen;
+        if (remaining > 0) {
+          stderrBufs.push(buf.subarray(0, remaining));
+          stderrLen += Math.min(buf.length, remaining);
+        }
+      });
+      let timer;
+      let settled = false;
+      let stdoutEnded = false;
+      let stderrEnded = false;
+      const cleanup = () => {
+        if (timer)
+          clearTimeout(timer);
+      };
+      if (opts?.timeout && opts.timeout > 0) {
+        const timeoutMs = opts.timeout * 1e3;
+        timer = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            stream.destroy();
+            reject(new Error(`Exec timed out after ${opts.timeout}s`));
+          }
+        }, timeoutMs);
+      }
+      const tryResolve = async () => {
+        if (!stdoutEnded || !stderrEnded)
+          return;
+        if (settled)
+          return;
+        settled = true;
+        cleanup();
+        try {
+          const info = await exec.inspect();
+          resolve5({
+            exitCode: info.ExitCode ?? 1,
+            stdout: Buffer.concat(stdoutBufs).toString("utf-8"),
+            stderr: Buffer.concat(stderrBufs).toString("utf-8")
+          });
+        } catch (err2) {
+          reject(err2);
+        }
+      };
+      stdoutPT.on("end", () => {
+        stdoutEnded = true;
+        tryResolve();
+      });
+      stderrPT.on("end", () => {
+        stderrEnded = true;
+        tryResolve();
+      });
+      stream.on("error", (err2) => {
+        if (!settled) {
+          settled = true;
+          cleanup();
+          reject(err2);
+        }
+      });
+      this.demux(stream, stdoutPT, stderrPT);
+    });
+  }
+};
+
+// ../sandbox/dist/pool.js
+function parseMemory(mem) {
+  const match = mem.match(/^(\d+(?:\.\d+)?)\s*([mg])$/i);
+  if (!match)
+    throw new Error(`Invalid memory value: ${mem}`);
+  const value = parseFloat(match[1]);
+  const unit = match[2].toLowerCase();
+  if (unit === "m")
+    return Math.round(value * 1024 * 1024);
+  return Math.round(value * 1024 * 1024 * 1024);
+}
+function parseCpu(cpu) {
+  const value = parseFloat(cpu);
+  if (Number.isNaN(value))
+    throw new Error(`Invalid cpu value: ${cpu}`);
+  return Math.round(value * 1e9);
+}
+var DockerContainerPool = class {
+  docker;
+  image;
+  maxTotal;
+  // C3: idle cache keyed by trust level to prevent cross-trust reuse
+  idle = /* @__PURE__ */ new Map([
+    ["sandboxed", /* @__PURE__ */ new Set()],
+    ["trusted", /* @__PURE__ */ new Set()]
+  ]);
+  busy = /* @__PURE__ */ new Set();
+  containerTrust = /* @__PURE__ */ new Map();
+  constructor(docker, config) {
+    this.docker = docker;
+    this.image = config.image;
+    this.maxTotal = config.maxTotal;
+  }
+  get idleCount() {
+    let count = 0;
+    for (const set of this.idle.values())
+      count += set.size;
+    return count;
+  }
+  /* ---- acquire ---- */
+  async acquire(opts) {
+    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);
+      return container2;
+    }
+    const total = this.idleCount + this.busy.size;
+    if (total >= this.maxTotal) {
+      throw new Error("Pool limit reached");
+    }
+    const raw = await this.docker.createContainer(this.buildCreateOpts(opts));
+    await raw.start();
+    const modem = this.docker.modem;
+    const demux = modem.demuxStream.bind(modem);
+    const container = new DockerContainer(raw, demux);
+    this.containerTrust.set(container.id, opts.trust);
+    this.busy.add(container);
+    return container;
+  }
+  /* ---- release ---- */
+  async release(container) {
+    this.busy.delete(container);
+    if (container.status === "stopped") {
+      this.containerTrust.delete(container.id);
+      return;
+    }
+    const trust = this.containerTrust.get(container.id) ?? "sandboxed";
+    this.idle.get(trust).add(container);
+  }
+  /* ---- destroy ---- */
+  async destroy(container) {
+    this.busy.delete(container);
+    for (const set of this.idle.values())
+      set.delete(container);
+    this.containerTrust.delete(container.id);
+    await container.stop();
+  }
+  /* ---- destroyAll ---- */
+  async destroyAll() {
+    const all = [...this.busy];
+    for (const set of this.idle.values()) {
+      all.push(...set);
+      set.clear();
+    }
+    this.busy.clear();
+    this.containerTrust.clear();
+    await Promise.allSettled(all.map((c) => c.stop()));
+  }
+  /* ---- stats ---- */
+  stats() {
+    const idle = this.idleCount;
+    return {
+      idle,
+      busy: this.busy.size,
+      total: idle + this.busy.size,
+      maxTotal: this.maxTotal
+    };
+  }
+  /* ---- internal ---- */
+  buildCreateOpts(opts) {
+    const isSandboxed = opts.trust === "sandboxed";
+    const hostConfig = {
+      Memory: parseMemory(opts.memory),
+      NanoCpus: parseCpu(opts.cpu),
+      PidsLimit: 512
+      // I6: prevent fork bombs
+    };
+    if (!isSandboxed) {
+      hostConfig.NetworkMode = "host";
+    }
+    if (opts.mounts?.length) {
+      hostConfig.Binds = opts.mounts.map((m) => `${m.host}:${m.container}${m.readonly ? ":ro" : ""}`);
+    }
+    const createOpts = {
+      Image: this.image,
+      Cmd: ["sleep", "infinity"],
+      WorkingDir: "/workspace",
+      NetworkDisabled: isSandboxed,
+      HostConfig: hostConfig
+    };
+    if (opts.env) {
+      createOpts.Env = Object.entries(opts.env).map(([k, v]) => `${k}=${v}`);
+    }
+    return createOpts;
+  }
+};
+
+// ../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";
+var FileMemoryStore = class {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  async read(path) {
+    return readFile3(this.resolve(path), "utf-8");
+  }
+  async write(path, content) {
+    const full = this.resolve(path);
+    await mkdir2(dirname(full), { recursive: true });
+    await writeFile(full, content, "utf-8");
+  }
+  async append(path, content) {
+    const full = this.resolve(path);
+    try {
+      const existing = await readFile3(full, "utf-8");
+      await writeFile(full, existing + content, "utf-8");
+    } catch {
+      await this.write(path, content);
+    }
+  }
+  async list(directory) {
+    const dir = directory ? this.resolve(directory) : this.basePath;
+    return this.listRecursive(dir);
+  }
+  async exists(path) {
+    try {
+      await access(this.resolve(path));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  resolve(path) {
+    return join3(this.basePath, path);
+  }
+  async listRecursive(dir) {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      const full = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...await this.listRecursive(full));
+      } else {
+        files.push(relative(this.basePath, full));
+      }
+    }
+    return files;
+  }
+};
+
+// ../memory/dist/ingest.js
+var EXTRACTION_PROMPT = `You are a memory extraction agent. Given a conversation, extract key factual observations about the user.
+
+Rules:
+- Return a markdown bullet list of observations (one per line, starting with "- ")
+- Only extract facts, preferences, decisions, plans, and personal details
+- Be concise: one fact per bullet
+- If there are no notable observations, return exactly "No notable observations."
+- Do not include greetings, small talk, or meta-conversation
+- Use present tense ("User prefers X", not "User said they prefer X")
+
+Example output:
+- User prefers TypeScript over JavaScript
+- User is building a project called Augure
+- User lives in Bordeaux, France`;
+var MemoryIngester = class {
+  llm;
+  store;
+  constructor(llm, store) {
+    this.llm = llm;
+    this.store = store;
+  }
+  async ingest(conversation) {
+    if (conversation.length === 0)
+      return;
+    const conversationText = conversation.filter((m) => m.role === "user" || m.role === "assistant").map((m) => `${m.role}: ${m.content}`).join("\n");
+    const messages = [
+      { role: "system", content: EXTRACTION_PROMPT },
+      { role: "user", content: conversationText }
+    ];
+    const response = await this.llm.chat(messages);
+    const observations = this.parseObservations(response.content);
+    if (observations.length === 0)
+      return;
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const block = `## ${date}
+${observations.map((o) => `- ${o}`).join("\n")}
+
+`;
+    await this.store.append("observations.md", block);
+  }
+  parseObservations(content) {
+    const lines = content.split("\n");
+    return lines.filter((line) => line.trim().startsWith("- ")).map((line) => line.trim().slice(2).trim()).filter((line) => line.length > 0);
+  }
+};
+
+// ../memory/dist/retrieve.js
+var PRIORITY_FILES = ["identity.md", "observations.md"];
+var CHARS_PER_TOKEN = 4;
+var MemoryRetriever = class {
+  store;
+  maxChars;
+  constructor(store, options = {}) {
+    this.store = store;
+    const maxTokens = options.maxTokens ?? 1e4;
+    this.maxChars = maxTokens * CHARS_PER_TOKEN;
+  }
+  async retrieve() {
+    const allFiles = await this.safeList();
+    if (allFiles.length === 0)
+      return "";
+    const prioritySet = new Set(PRIORITY_FILES);
+    const orderedFiles = [
+      ...PRIORITY_FILES.filter((f) => allFiles.includes(f)),
+      ...allFiles.filter((f) => !prioritySet.has(f)).sort()
+    ];
+    const sections = [];
+    let totalChars = 0;
+    for (const file of orderedFiles) {
+      if (totalChars >= this.maxChars)
+        break;
+      try {
+        const content = await this.store.read(file);
+        const header = `### ${file}`;
+        const section = `${header}
+${content}`;
+        const sectionChars = section.length;
+        if (totalChars + sectionChars > this.maxChars) {
+          const remaining = this.maxChars - totalChars;
+          if (remaining > header.length + 50) {
+            sections.push(section.slice(0, remaining) + "\n[...truncated]");
+            totalChars = this.maxChars;
+          }
+          break;
+        }
+        sections.push(section);
+        totalChars += sectionChars;
+      } catch {
+      }
+    }
+    return sections.join("\n\n");
+  }
+  async safeList() {
+    try {
+      return await this.store.list();
+    } catch {
+      return [];
+    }
+  }
+};
+
+// ../scheduler/dist/cron.js
+import { createTask, validate } from "node-cron";
+var CronScheduler = class {
+  store;
+  jobs = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  handlers = [];
+  persistChain = Promise.resolve();
+  constructor(store) {
+    this.store = store;
+  }
+  onJobTrigger(handler) {
+    this.handlers.push(handler);
+  }
+  addJob(job) {
+    if (!validate(job.cron)) {
+      throw new Error(`Invalid cron expression: ${job.cron}`);
+    }
+    this.jobs.set(job.id, job);
+    if (job.enabled) {
+      const task = createTask(job.cron, () => {
+        void this.executeHandlers(job);
+      });
+      this.tasks.set(job.id, task);
+    }
+    this.persist();
+  }
+  removeJob(id) {
+    const task = this.tasks.get(id);
+    if (task) {
+      task.stop();
+      this.tasks.delete(id);
+    }
+    this.jobs.delete(id);
+    this.persist();
+  }
+  listJobs() {
+    return Array.from(this.jobs.values());
+  }
+  async triggerJob(id) {
+    const job = this.jobs.get(id);
+    if (!job) {
+      throw new Error(`Job not found: ${id}`);
+    }
+    await this.executeHandlers(job);
+  }
+  async loadPersistedJobs() {
+    if (!this.store)
+      return;
+    const jobs = await this.store.load();
+    for (const job of jobs) {
+      this.addJob(job);
+    }
+  }
+  start() {
+    for (const task of this.tasks.values()) {
+      task.start();
+    }
+  }
+  stop() {
+    for (const task of this.tasks.values()) {
+      task.stop();
+    }
+  }
+  persist() {
+    if (!this.store)
+      return;
+    const jobs = this.listJobs();
+    this.persistChain = this.persistChain.then(() => this.store.save(jobs));
+  }
+  async executeHandlers(job) {
+    for (const handler of this.handlers) {
+      await handler(job);
+    }
+  }
+};
+
+// ../scheduler/dist/jobs.js
+import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var JobStore = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async load() {
+    try {
+      const raw = await readFile4(this.filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  async save(jobs) {
+    await mkdir3(dirname2(this.filePath), { recursive: true });
+    await writeFile2(this.filePath, JSON.stringify(jobs, null, 2), "utf-8");
+  }
+};
+
+// ../scheduler/dist/heartbeat.js
+var HEARTBEAT_PROMPT = `You are a monitoring agent. Your job is to review the user's memory and decide if any proactive action is needed right now.
+
+Review the memory context below and determine:
+1. Are there any time-sensitive tasks or reminders?
+2. Should the user be notified about something?
+3. Are there any scheduled checks that need to run?
+
+If action is needed, respond with:
+ACTION: <description of what to do>
+
+If no action is needed, respond with:
+ACTION: none
+
+Be concise. Only suggest actions that are clearly needed based on the memory context.`;
+var Heartbeat = class {
+  config;
+  timer;
+  constructor(config) {
+    this.config = config;
+  }
+  async tick() {
+    const memoryContent = await this.loadMemory();
+    const messages = [
+      { role: "system", content: HEARTBEAT_PROMPT },
+      {
+        role: "user",
+        content: `Current time: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Memory
+${memoryContent}`
+      }
+    ];
+    const response = await this.config.llm.chat(messages);
+    const action = this.parseAction(response.content);
+    if (action && action.toLowerCase() !== "none") {
+      await this.config.onAction(action);
+    }
+  }
+  start() {
+    this.timer = setInterval(() => {
+      this.tick().catch((err2) => console.error("[augure] Heartbeat error:", err2));
+    }, this.config.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  parseAction(content) {
+    const match = content.match(/ACTION:\s*(.+)/i);
+    return match?.[1]?.trim();
+  }
+  async loadMemory() {
+    try {
+      const exists = await this.config.memory.exists("observations.md");
+      if (exists) {
+        return this.config.memory.read("observations.md");
+      }
+    } catch {
+    }
+    return "(no memory available)";
+  }
+};
+
+// ../scheduler/dist/interval.js
+var UNITS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5
+};
+function parseInterval(input) {
+  const match = input.match(/^(\d+)([smh])$/);
+  if (!match) {
+    throw new Error(`Invalid interval format: "${input}". Expected: <number><s|m|h> (e.g. "30m")`);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  if (value <= 0) {
+    throw new Error(`Interval must be positive, got: ${value}`);
+  }
+  return value * UNITS[unit];
+}
+
+// ../skills/dist/manager.js
+import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir4, readdir as readdir3, rm, access as access2 } from "fs/promises";
+import { join as join4 } from "path";
+
+// ../skills/dist/parser.js
+import matter2 from "gray-matter";
+function parseSkillMd(content) {
+  const { data, content: body } = matter2(content);
+  const meta = validateSkillMeta(data);
+  return { meta, body: body.trim() };
+}
+function serializeSkillMd(meta, body) {
+  return matter2.stringify(body, JSON.parse(JSON.stringify(meta)));
+}
+function validateSkillMeta(raw) {
+  if (!raw.id || typeof raw.id !== "string")
+    throw new Error("skill.md: missing or invalid 'id'");
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(raw.id))
+    throw new Error(`skill.md: invalid id format '${raw.id}' (must be lowercase slug)`);
+  if (!raw.name || typeof raw.name !== "string")
+    throw new Error("skill.md: missing or invalid 'name'");
+  const version2 = typeof raw.version === "number" ? raw.version : 1;
+  if (!Number.isInteger(version2) || version2 < 1)
+    throw new Error("skill.md: 'version' must be a positive integer");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const created = typeof raw.created === "string" ? raw.created : now;
+  const updated = typeof raw.updated === "string" ? raw.updated : now;
+  const status = typeof raw.status === "string" ? raw.status : "draft";
+  const validStatuses = ["draft", "testing", "active", "paused", "broken"];
+  if (!validStatuses.includes(status))
+    throw new Error(`skill.md: invalid status '${status}'`);
+  const trigger = raw.trigger;
+  if (!trigger || typeof trigger !== "object")
+    throw new Error("skill.md: missing 'trigger'");
+  const triggerType = trigger.type;
+  if (!["cron", "manual", "event"].includes(triggerType))
+    throw new Error(`skill.md: invalid trigger.type '${triggerType}'`);
+  if (triggerType === "cron" && (!trigger.schedule || typeof trigger.schedule !== "string")) {
+    throw new Error("skill.md: cron trigger requires 'schedule'");
+  }
+  const sandbox = typeof raw.sandbox === "boolean" ? raw.sandbox : true;
+  const tools = Array.isArray(raw.tools) ? raw.tools : [];
+  const tags = Array.isArray(raw.tags) ? raw.tags : [];
+  return {
+    id: raw.id,
+    name: raw.name,
+    version: version2,
+    created,
+    updated,
+    status,
+    trigger: {
+      type: triggerType,
+      schedule: trigger.schedule,
+      channel: trigger.channel
+    },
+    sandbox,
+    tools,
+    tags
+  };
+}
+
+// ../skills/dist/manager.js
+var SkillManager = class {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  /** List all skills from the index (rebuilds if missing) */
+  async list() {
+    try {
+      const index = await this.readIndex();
+      return index.skills;
+    } catch {
+      const index = await this.rebuildIndex();
+      return index.skills;
+    }
+  }
+  /** Load a single skill by ID */
+  async get(id) {
+    const dir = join4(this.basePath, id);
+    const mdContent = await readFile5(join4(dir, "skill.md"), "utf-8");
+    const { meta, body } = parseSkillMd(mdContent);
+    let code;
+    try {
+      code = await readFile5(join4(dir, "skill.ts"), "utf-8");
+    } catch {
+    }
+    let testCode;
+    try {
+      testCode = await readFile5(join4(dir, "skill.test.ts"), "utf-8");
+    } catch {
+    }
+    return { meta, body, code, testCode };
+  }
+  /** Save a skill to disk (creates directory, writes files, updates index) */
+  async save(skill) {
+    const dir = join4(this.basePath, skill.meta.id);
+    await mkdir4(dir, { recursive: true });
+    const mdContent = serializeSkillMd(skill.meta, skill.body);
+    await writeFile3(join4(dir, "skill.md"), mdContent, "utf-8");
+    if (skill.code !== void 0) {
+      await writeFile3(join4(dir, "skill.ts"), skill.code, "utf-8");
+    }
+    if (skill.testCode !== void 0) {
+      await writeFile3(join4(dir, "skill.test.ts"), skill.testCode, "utf-8");
+    }
+    await this.updateIndex(skill.meta);
+  }
+  /** Delete a skill directory and remove from index */
+  async delete(id) {
+    const dir = join4(this.basePath, id);
+    await rm(dir, { recursive: true, force: true });
+    await this.removeFromIndex(id);
+  }
+  /** Update just the status of a skill */
+  async updateStatus(id, status) {
+    const skill = await this.get(id);
+    skill.meta.status = status;
+    skill.meta.updated = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(skill);
+  }
+  /** Bump version number, returns the new version */
+  async bumpVersion(id) {
+    const skill = await this.get(id);
+    skill.meta.version += 1;
+    skill.meta.updated = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(skill);
+    return skill.meta.version;
+  }
+  /** Save a run result to runs/<timestamp>.json */
+  async saveRun(result) {
+    const runsDir = join4(this.basePath, result.skillId, "runs");
+    await mkdir4(runsDir, { recursive: true });
+    const filename = `${result.timestamp.replace(/[:.]/g, "-")}.json`;
+    await writeFile3(join4(runsDir, filename), JSON.stringify(result, null, 2), "utf-8");
+  }
+  /** Load recent run results for a skill, sorted newest first */
+  async getRuns(id, limit = 10) {
+    const runsDir = join4(this.basePath, id, "runs");
+    let files;
+    try {
+      files = await readdir3(runsDir);
+    } catch {
+      return [];
+    }
+    const jsonFiles = files.filter((f) => f.endsWith(".json")).sort().reverse();
+    const results = [];
+    for (const file of jsonFiles.slice(0, limit)) {
+      try {
+        const raw = await readFile5(join4(runsDir, file), "utf-8");
+        results.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    return results;
+  }
+  /** Get the most recent run result */
+  async getLastRun(id) {
+    const runs = await this.getRuns(id, 1);
+    return runs[0] ?? null;
+  }
+  /** Rebuild skills-index.json by scanning all skill directories */
+  async rebuildIndex() {
+    await mkdir4(this.basePath, { recursive: true });
+    let entries;
+    try {
+      entries = await readdir3(this.basePath, { withFileTypes: true }).then((e) => e.filter((d) => d.isDirectory()).map((d) => d.name));
+    } catch {
+      entries = [];
+    }
+    const skills = [];
+    for (const dir of entries) {
+      try {
+        const mdContent = await readFile5(join4(this.basePath, dir, "skill.md"), "utf-8");
+        const { meta } = parseSkillMd(mdContent);
+        skills.push(metaToIndexEntry(meta));
+      } catch {
+      }
+    }
+    const index = { version: 1, skills };
+    await this.writeIndex(index);
+    return index;
+  }
+  /** Check if a skill exists on disk */
+  async exists(id) {
+    try {
+      await access2(join4(this.basePath, id, "skill.md"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async readIndex() {
+    const raw = await readFile5(join4(this.basePath, "skills-index.json"), "utf-8");
+    return JSON.parse(raw);
+  }
+  async writeIndex(index) {
+    await mkdir4(this.basePath, { recursive: true });
+    await writeFile3(join4(this.basePath, "skills-index.json"), JSON.stringify(index, null, 2), "utf-8");
+  }
+  async updateIndex(meta) {
+    let index;
+    try {
+      index = await this.readIndex();
+    } catch {
+      index = { version: 1, skills: [] };
+    }
+    const entry = metaToIndexEntry(meta);
+    const idx = index.skills.findIndex((s) => s.id === meta.id);
+    if (idx >= 0) {
+      index.skills[idx] = entry;
+    } else {
+      index.skills.push(entry);
+    }
+    await this.writeIndex(index);
+  }
+  async removeFromIndex(id) {
+    let index;
+    try {
+      index = await this.readIndex();
+    } catch {
+      return;
+    }
+    index.skills = index.skills.filter((s) => s.id !== id);
+    await this.writeIndex(index);
+  }
+};
+function metaToIndexEntry(meta) {
+  return {
+    id: meta.id,
+    name: meta.name,
+    version: meta.version,
+    status: meta.status,
+    trigger: meta.trigger,
+    tags: meta.tags,
+    updated: meta.updated
+  };
+}
+
+// ../skills/dist/llm-parser.js
+function parseSkillResponse(content) {
+  const namedResult = parseNamedFences(content);
+  if (namedResult)
+    return namedResult;
+  const sectionResult = parseSectionHeaders(content);
+  if (sectionResult)
+    return sectionResult;
+  const sequentialResult = parseSequentialBlocks(content);
+  if (sequentialResult)
+    return sequentialResult;
+  return null;
+}
+function parseNamedFences(content) {
+  const fencePattern = /```\w*\s+(?:filename=)?(\S+)\s*\n([\s\S]*?)```/g;
+  const blocks = /* @__PURE__ */ new Map();
+  let match;
+  while ((match = fencePattern.exec(content)) !== null) {
+    blocks.set(match[1], match[2].trim());
+  }
+  const skillMd = blocks.get("skill.md");
+  const skillTs = blocks.get("skill.ts");
+  const skillTestTs = blocks.get("skill.test.ts");
+  if (skillMd && skillTs && skillTestTs) {
+    return { skillMd, skillTs, skillTestTs };
+  }
+  return null;
+}
+function parseSectionHeaders(content) {
+  const sections = /* @__PURE__ */ new Map();
+  const sectionPattern = /#{2,3}\s+(skill\.(?:md|ts|test\.ts))\s*\n+```\w*\n([\s\S]*?)```/g;
+  let match;
+  while ((match = sectionPattern.exec(content)) !== null) {
+    sections.set(match[1], match[2].trim());
+  }
+  const skillMd = sections.get("skill.md");
+  const skillTs = sections.get("skill.ts");
+  const skillTestTs = sections.get("skill.test.ts");
+  if (skillMd && skillTs && skillTestTs) {
+    return { skillMd, skillTs, skillTestTs };
+  }
+  return null;
+}
+function parseSequentialBlocks(content) {
+  const blockPattern = /```\w*\n([\s\S]*?)```/g;
+  const blocks = [];
+  let match;
+  while ((match = blockPattern.exec(content)) !== null) {
+    blocks.push(match[1].trim());
+  }
+  if (blocks.length >= 3) {
+    return {
+      skillMd: blocks[0],
+      skillTs: blocks[1],
+      skillTestTs: blocks[2]
+    };
+  }
+  return null;
+}
+
+// ../skills/dist/generator.js
+var GENERATION_SYSTEM_PROMPT = `You are a skill generator for the Augure AI agent. When given a description of a task, you generate three files that implement it.
+
+## Output Format
+
+You MUST output exactly three fenced code blocks with filenames:
+
+\`\`\`yaml filename=skill.md
+---
+id: skill-id-here
+name: Human Readable Name
+version: 1
+status: draft
+trigger:
+  type: TRIGGER_TYPE
+  schedule: "CRON_EXPRESSION"  # only if trigger type is cron
+  channel: CHANNEL              # optional
+sandbox: true
+tools: []
+tags: []
+---
+
+# Skill Name
+
+## Goal
+What this skill does.
+
+## Strategy
+Step by step approach.
+\`\`\`
+
+\`\`\`typescript filename=skill.ts
+import type { SkillContext } from "@augure/types";
+
+export default async function execute(ctx: SkillContext): Promise<{ output: string }> {
+  // Implementation here
+  return { output: "result" };
+}
+\`\`\`
+
+\`\`\`typescript filename=skill.test.ts
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+describe("skill-id", () => {
+  it("should produce expected output", async () => {
+    // Test the skill logic
+    assert.ok(true);
+  });
+});
+\`\`\`
+
+## Rules
+- The skill ID must be a lowercase slug (e.g., "daily-digest", "price-alert")
+- Tests MUST use node:test and node:assert (NOT vitest or jest)
+- The skill.ts default export must be an async function taking SkillContext
+- Keep the implementation focused and minimal`;
+var REGENERATION_SYSTEM_PROMPT = `You are a skill code fixer for the Augure AI agent. A skill failed to execute. You must fix the code.
+
+## Rules
+- Output exactly two fenced code blocks: skill.ts and skill.test.ts
+- Keep the same function signature and approach
+- Fix the specific error described
+- Tests use node:test and node:assert (NOT vitest or jest)
+
+Output format:
+\`\`\`typescript filename=skill.ts
+// fixed code
+\`\`\`
+
+\`\`\`typescript filename=skill.test.ts
+// fixed test
+\`\`\``;
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+var SkillGenerator = class {
+  llm;
+  constructor(llm) {
+    this.llm = llm;
+  }
+  async generate(request) {
+    const id = slugify(request.description);
+    if (!id) {
+      return { success: false, error: "Could not generate a valid skill ID from description" };
+    }
+    const userPrompt = [
+      `Create a skill with the following specification:`,
+      `- ID: ${id}`,
+      `- Description: ${request.description}`,
+      `- Trigger type: ${request.trigger.type}`,
+      request.trigger.schedule ? `- Schedule: ${request.trigger.schedule}` : null,
+      request.trigger.channel ? `- Channel: ${request.trigger.channel}` : null,
+      request.tags?.length ? `- Tags: ${request.tags.join(", ")}` : null,
+      `- Sandbox: ${request.sandbox !== false}`
+    ].filter(Boolean).join("\n");
+    try {
+      const response = await this.llm.chat([
+        { role: "system", content: GENERATION_SYSTEM_PROMPT },
+        { role: "user", content: userPrompt }
+      ]);
+      const parsed = parseSkillResponse(response.content);
+      if (!parsed) {
+        return { success: false, error: "Failed to parse LLM response: missing code blocks" };
+      }
+      const { meta, body } = parseSkillMd(parsed.skillMd);
+      meta.id = id;
+      const skill = {
+        meta,
+        body,
+        code: parsed.skillTs,
+        testCode: parsed.skillTestTs
+      };
+      return { success: true, skill };
+    } catch (err2) {
+      return {
+        success: false,
+        error: err2 instanceof Error ? err2.message : String(err2)
+      };
+    }
+  }
+  async regenerateCode(skill, error) {
+    const userPrompt = [
+      `## Skill: ${skill.meta.name} (${skill.meta.id})`,
+      ``,
+      `## Description`,
+      skill.body,
+      ``,
+      `## Current code (skill.ts)`,
+      "```typescript",
+      skill.code ?? "// no code yet",
+      "```",
+      ``,
+      `## Error`,
+      "```",
+      error,
+      "```",
+      ``,
+      `Fix the code to resolve this error.`
+    ].join("\n");
+    try {
+      const response = await this.llm.chat([
+        { role: "system", content: REGENERATION_SYSTEM_PROMPT },
+        { role: "user", content: userPrompt }
+      ]);
+      const blockPattern = /```\w*(?:\s+\S+)?\s*\n([\s\S]*?)```/g;
+      const blocks = [];
+      let match;
+      while ((match = blockPattern.exec(response.content)) !== null) {
+        blocks.push(match[1].trim());
+      }
+      if (blocks.length < 2)
+        return null;
+      return { code: blocks[0], testCode: blocks[1] };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// ../skills/dist/runner.js
+var HARNESS_TEMPLATE = `
+import skill from "./skill.ts";
+import { readFile, readdir, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+// Load injected config from separate JSON file (avoids template injection issues)
+const __injected = JSON.parse(await readFile("/workspace/__config.json", "utf-8"));
+
+const ctx = {
+  exec: async (command, opts) => {
+    const { execSync } = await import("node:child_process");
+    try {
+      const stdout = execSync(command, {
+        encoding: "utf-8",
+        timeout: (opts?.timeout ?? 30) * 1000,
+        env: { ...process.env, ...(opts?.env ?? {}) },
+        maxBuffer: 10 * 1024 * 1024,
+      });
+      return { exitCode: 0, stdout, stderr: "" };
+    } catch (err) {
+      return {
+        exitCode: err.status ?? 1,
+        stdout: err.stdout ?? "",
+        stderr: err.stderr ?? err.message,
+      };
+    }
+  },
+  memory: {
+    read: async (path) => readFile(join("/memory", path), "utf-8"),
+    list: async (dir) => {
+      try {
+        return await readdir(join("/memory", dir ?? ""));
+      } catch {
+        return [];
+      }
+    },
+  },
+  state: {
+    _data: {},
+    _loaded: false,
+    _load: async function() {
+      if (this._loaded) return;
+      try { this._data = JSON.parse(await readFile("/state/state.json", "utf-8")); } catch { this._data = {}; }
+      this._loaded = true;
+    },
+    get: async function(key) { await this._load(); return this._data[key]; },
+    set: async function(key, value) {
+      await this._load();
+      this._data[key] = value;
+      await mkdir("/state", { recursive: true });
+      await writeFile("/state/state.json", JSON.stringify(this._data, null, 2));
+    },
+    delete: async function(key) {
+      await this._load();
+      delete this._data[key];
+      await mkdir("/state", { recursive: true });
+      await writeFile("/state/state.json", JSON.stringify(this._data, null, 2));
+    },
+  },
+  previousRun: __injected.previousRun,
+  config: __injected.config,
+};
+
+try {
+  const result = await skill(ctx);
+  console.log(JSON.stringify({ success: true, output: result?.output ?? "" }));
+} catch (err) {
+  console.log(JSON.stringify({ success: false, error: err.message ?? String(err) }));
+  process.exit(1);
+}
+`;
+var SkillRunner = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async run(skillId) {
+    const start = Date.now();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const skill = await this.config.manager.get(skillId);
+    if (!skill.code) {
+      const result = {
+        skillId,
+        timestamp,
+        success: false,
+        error: "Skill has no code (skill.ts)",
+        durationMs: Date.now() - start
+      };
+      await this.config.manager.saveRun(result);
+      return result;
+    }
+    let container;
+    try {
+      container = await this.config.pool.acquire({
+        trust: skill.meta.sandbox ? "sandboxed" : "trusted",
+        timeout: this.config.defaults.timeout,
+        memory: this.config.defaults.memoryLimit,
+        cpu: this.config.defaults.cpuLimit
+      });
+    } catch (err2) {
+      const result = {
+        skillId,
+        timestamp,
+        success: false,
+        error: `Failed to acquire container: ${err2 instanceof Error ? err2.message : String(err2)}`,
+        durationMs: Date.now() - start
+      };
+      await this.config.manager.saveRun(result);
+      return result;
+    }
+    try {
+      await container.exec("mkdir -p /workspace");
+      const codeB64 = Buffer.from(skill.code).toString("base64");
+      await container.exec(`sh -c 'echo "${codeB64}" | base64 -d > /workspace/skill.ts'`);
+      const previousRun = await this.config.manager.getLastRun(skillId);
+      const configData = JSON.stringify({ previousRun, config: skill.meta });
+      const configB64 = Buffer.from(configData).toString("base64");
+      await container.exec(`sh -c 'echo "${configB64}" | base64 -d > /workspace/__config.json'`);
+      const harnessB64 = Buffer.from(HARNESS_TEMPLATE).toString("base64");
+      await container.exec(`sh -c 'echo "${harnessB64}" | base64 -d > /workspace/harness.ts'`);
+      const execResult = await container.exec("npx tsx /workspace/harness.ts", { timeout: this.config.defaults.timeout, cwd: "/workspace" });
+      let success = false;
+      let output = "";
+      let error;
+      if (execResult.exitCode === 0 && execResult.stdout.trim()) {
+        try {
+          const parsed = JSON.parse(execResult.stdout.trim().split("\n").pop());
+          success = parsed.success === true;
+          output = parsed.output ?? "";
+          error = parsed.error;
+        } catch {
+          output = execResult.stdout;
+          success = true;
+        }
+      } else {
+        success = false;
+        error = execResult.stderr || execResult.stdout || "Unknown error";
+      }
+      const result = {
+        skillId,
+        timestamp,
+        success,
+        output: output || void 0,
+        error,
+        durationMs: Date.now() - start
+      };
+      await this.config.manager.saveRun(result);
+      return result;
+    } catch (err2) {
+      const result = {
+        skillId,
+        timestamp,
+        success: false,
+        error: err2 instanceof Error ? err2.message : String(err2),
+        durationMs: Date.now() - start
+      };
+      await this.config.manager.saveRun(result);
+      return result;
+    } finally {
+      await this.config.pool.release(container);
+    }
+  }
+};
+
+// ../skills/dist/tester.js
+var SkillTester = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async test(skill) {
+    if (!skill.testCode) {
+      return { success: false, passed: 0, failed: 0, output: "", error: "Skill has no test code" };
+    }
+    if (!skill.code) {
+      return { success: false, passed: 0, failed: 0, output: "", error: "Skill has no code" };
+    }
+    let container;
+    try {
+      container = await this.config.pool.acquire({
+        trust: "sandboxed",
+        timeout: this.config.defaults.timeout,
+        memory: this.config.defaults.memoryLimit,
+        cpu: this.config.defaults.cpuLimit
+      });
+    } catch (err2) {
+      return {
+        success: false,
+        passed: 0,
+        failed: 0,
+        output: "",
+        error: `Failed to acquire container: ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+    try {
+      await container.exec("mkdir -p /workspace");
+      const codeB64 = Buffer.from(skill.code).toString("base64");
+      await container.exec(`sh -c 'echo "${codeB64}" | base64 -d > /workspace/skill.ts'`);
+      const testB64 = Buffer.from(skill.testCode).toString("base64");
+      await container.exec(`sh -c 'echo "${testB64}" | base64 -d > /workspace/skill.test.ts'`);
+      const result = await container.exec("npx tsx --test --test-reporter=tap /workspace/skill.test.ts", { timeout: this.config.defaults.timeout, cwd: "/workspace" });
+      const { passed, failed } = parseTestOutput(result.stdout + result.stderr);
+      const success = result.exitCode === 0 && failed === 0;
+      return {
+        success,
+        passed,
+        failed,
+        output: result.stdout,
+        error: success ? void 0 : result.stderr || `Exit code: ${result.exitCode}`
+      };
+    } catch (err2) {
+      return {
+        success: false,
+        passed: 0,
+        failed: 0,
+        output: "",
+        error: err2 instanceof Error ? err2.message : String(err2)
+      };
+    } finally {
+      await this.config.pool.release(container);
+    }
+  }
+};
+function parseTestOutput(output) {
+  const passMatch = output.match(/# pass (\d+)/);
+  const failMatch = output.match(/# fail (\d+)/);
+  return {
+    passed: passMatch ? parseInt(passMatch[1], 10) : 0,
+    failed: failMatch ? parseInt(failMatch[1], 10) : 0
+  };
+}
+
+// ../skills/dist/state.js
+import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+var FileSkillState = class {
+  filePath;
+  data = {};
+  loaded = false;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async get(key) {
+    await this.ensureLoaded();
+    return this.data[key];
+  }
+  async set(key, value) {
+    await this.ensureLoaded();
+    this.data[key] = value;
+    await this.persist();
+  }
+  async delete(key) {
+    await this.ensureLoaded();
+    delete this.data[key];
+    await this.persist();
+  }
+  async ensureLoaded() {
+    if (this.loaded)
+      return;
+    try {
+      const raw = await readFile6(this.filePath, "utf-8");
+      this.data = JSON.parse(raw);
+    } catch {
+      this.data = {};
+    }
+    this.loaded = true;
+  }
+  async persist() {
+    await mkdir5(dirname3(this.filePath), { recursive: true });
+    await writeFile4(this.filePath, JSON.stringify(this.data, null, 2), "utf-8");
+  }
+};
+
+// ../skills/dist/healer.js
+import { join as join5 } from "path";
+var SkillHealer = class {
+  config;
+  stateCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  /** Called after each skill run to check for failures and trigger healing */
+  async onRunComplete(result) {
+    if (result.success) {
+      const state2 = this.getState(result.skillId);
+      await state2.set("consecutive-failures", "0");
+      return { healed: false, paused: false };
+    }
+    const state = this.getState(result.skillId);
+    const raw = await state.get("consecutive-failures");
+    const failures = (raw ? parseInt(raw, 10) : 0) + 1;
+    await state.set("consecutive-failures", String(failures));
+    if (failures >= this.config.maxAttempts) {
+      await this.config.manager.updateStatus(result.skillId, "paused");
+      return { healed: false, paused: true, error: `Paused after ${failures} consecutive failures` };
+    }
+    return this.heal(result.skillId, result.error ?? "Unknown error");
+  }
+  /** Attempt to heal a broken skill */
+  async heal(skillId, error) {
+    const skill = await this.config.manager.get(skillId);
+    const healError = error ?? (await this.config.manager.getLastRun(skillId))?.error ?? "Unknown error";
+    const fixed = await this.config.generator.regenerateCode(skill, healError);
+    if (!fixed) {
+      await this.config.manager.updateStatus(skillId, "broken");
+      return { healed: false, paused: false, error: "LLM could not generate a fix" };
+    }
+    skill.code = fixed.code;
+    skill.testCode = fixed.testCode;
+    const testResult = await this.config.tester.test(skill);
+    if (!testResult.success) {
+      await this.config.manager.updateStatus(skillId, "broken");
+      return { healed: false, paused: false, error: `Fix failed tests: ${testResult.error}` };
+    }
+    await this.config.manager.save(skill);
+    await this.config.manager.bumpVersion(skillId);
+    await this.config.manager.updateStatus(skillId, "active");
+    const state = this.getState(skillId);
+    await state.set("consecutive-failures", "0");
+    return { healed: true, paused: false };
+  }
+  /** Check if a skill needs healing based on recent runs */
+  async needsHealing(skillId) {
+    const lastRun = await this.config.manager.getLastRun(skillId);
+    if (!lastRun)
+      return false;
+    return !lastRun.success;
+  }
+  getState(skillId) {
+    let state = this.stateCache.get(skillId);
+    if (!state) {
+      state = new FileSkillState(join5(this.config.skillsPath, skillId, "state.json"));
+      this.stateCache.set(skillId, state);
+    }
+    return state;
+  }
+};
+
+// ../skills/dist/scheduler-bridge.js
+var JOB_PREFIX = "skill:";
+var SkillSchedulerBridge = class {
+  scheduler;
+  manager;
+  constructor(scheduler, manager) {
+    this.scheduler = scheduler;
+    this.manager = manager;
+  }
+  /** Register cron jobs for all active cron-triggered skills */
+  async syncAll() {
+    const skills = await this.manager.list();
+    const existingJobs = new Set(this.scheduler.listJobs().filter((j) => j.id.startsWith(JOB_PREFIX)).map((j) => j.id));
+    for (const skill of skills) {
+      const jobId = `${JOB_PREFIX}${skill.id}`;
+      if (skill.status === "active" && skill.trigger.type === "cron" && skill.trigger.schedule) {
+        if (!existingJobs.has(jobId)) {
+          try {
+            this.scheduler.addJob({
+              id: jobId,
+              cron: skill.trigger.schedule,
+              prompt: `[skill:run:${skill.id}]`,
+              channel: skill.trigger.channel ?? "default",
+              enabled: true
+            });
+          } catch (err2) {
+            console.error(`[skills] Failed to register cron for ${skill.id}:`, err2);
+          }
+        }
+        existingJobs.delete(jobId);
+      }
+    }
+    for (const orphanId of existingJobs) {
+      this.scheduler.removeJob(orphanId);
+    }
+  }
+  /** Register a single skill as a cron job */
+  register(skillId, schedule, channel) {
+    const jobId = `${JOB_PREFIX}${skillId}`;
+    try {
+      this.scheduler.removeJob(jobId);
+    } catch {
+    }
+    this.scheduler.addJob({
+      id: jobId,
+      cron: schedule,
+      prompt: `[skill:run:${skillId}]`,
+      channel: channel ?? "default",
+      enabled: true
+    });
+  }
+  /** Unregister a skill's cron job */
+  unregister(skillId) {
+    try {
+      this.scheduler.removeJob(`${JOB_PREFIX}${skillId}`);
+    } catch {
+    }
+  }
+  /** Check if a prompt is a skill run command, return skill ID if so */
+  static parseSkillPrompt(prompt) {
+    const match = prompt.match(/^\[skill:run:(.+)\]$/);
+    return match ? match[1] : null;
+  }
+};
+
+// ../skills/dist/hub.js
+var SkillHub = class {
+  config;
+  baseUrl;
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = `https://raw.githubusercontent.com/${config.repo}/${config.branch}`;
+  }
+  /** List available skills from the hub manifest */
+  async list() {
+    const url = `${this.baseUrl}/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch hub manifest: ${response.status} ${response.statusText}`);
+    }
+    const manifest = await response.json();
+    return manifest.skills;
+  }
+  /** Download a complete skill from the hub */
+  async download(skillId) {
+    const skillMd = await this.fetchFile(`skills/${skillId}/skill.md`);
+    const { meta, body } = parseSkillMd(skillMd);
+    let code;
+    try {
+      code = await this.fetchFile(`skills/${skillId}/skill.ts`);
+    } catch {
+    }
+    let testCode;
+    try {
+      testCode = await this.fetchFile(`skills/${skillId}/skill.test.ts`);
+    } catch {
+    }
+    meta.sandbox = true;
+    return { meta, body, code, testCode };
+  }
+  async fetchFile(path) {
+    const url = `${this.baseUrl}/${path}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${path}: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+  }
+};
+
+// ../skills/dist/tools.js
+function createSkillTools(deps) {
+  const { manager, runner, generator, healer, hub } = deps;
+  const createSkillTool = {
+    name: "create_skill",
+    description: "Create a new skill from a natural language description. Generates code, tests it, and deploys if successful.",
+    parameters: {
+      type: "object",
+      properties: {
+        description: { type: "string", description: "What the skill should do" },
+        trigger_type: { type: "string", enum: ["cron", "manual", "event"], description: "When the skill should run" },
+        schedule: { type: "string", description: "Cron expression (required if trigger_type is cron)" },
+        channel: { type: "string", description: "Channel to send results to" },
+        tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" }
+      },
+      required: ["description", "trigger_type"]
+    },
+    execute: async (params) => {
+      const p = params;
+      const result = await generator.generate({
+        description: p.description,
+        trigger: {
+          type: p.trigger_type,
+          schedule: p.schedule,
+          channel: p.channel
+        },
+        tags: p.tags
+      });
+      if (!result.success || !result.skill) {
+        return { success: false, output: `Failed to generate skill: ${result.error}` };
+      }
+      await manager.save(result.skill);
+      return {
+        success: true,
+        output: `Skill "${result.skill.meta.name}" (${result.skill.meta.id}) created with status: ${result.skill.meta.status}`
+      };
+    }
+  };
+  const listSkillsTool = {
+    name: "list_skills",
+    description: "List all skills with their status and trigger info",
+    parameters: { type: "object", properties: {} },
+    execute: async () => {
+      const skills = await manager.list();
+      if (skills.length === 0) {
+        return { success: true, output: "No skills installed." };
+      }
+      const lines = skills.map((s) => {
+        const trigger = s.trigger.type === "cron" ? `cron(${s.trigger.schedule})` : s.trigger.type;
+        return `- **${s.name}** (${s.id}) [${s.status}] trigger: ${trigger}`;
+      });
+      return { success: true, output: lines.join("\n") };
+    }
+  };
+  const runSkillTool = {
+    name: "run_skill",
+    description: "Manually trigger a skill execution by ID",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The skill ID to run" }
+      },
+      required: ["id"]
     },
+    execute: async (params) => {
+      const { id } = params;
+      if (!await manager.exists(id)) {
+        return { success: false, output: `Skill "${id}" not found` };
+      }
+      const result = await runner.run(id);
+      await healer.onRunComplete(result);
+      if (result.success) {
+        return { success: true, output: result.output ?? "Skill completed successfully" };
+      }
+      return { success: false, output: `Skill failed: ${result.error}` };
+    }
+  };
+  const manageSkillTool = {
+    name: "manage_skill",
+    description: "Manage a skill: pause, resume, or delete it",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The skill ID" },
+        action: { type: "string", enum: ["pause", "resume", "delete"], description: "Action to perform" }
+      },
+      required: ["id", "action"]
+    },
+    execute: async (params) => {
+      const { id, action } = params;
+      if (!await manager.exists(id)) {
+        return { success: false, output: `Skill "${id}" not found` };
+      }
+      switch (action) {
+        case "pause":
+          await manager.updateStatus(id, "paused");
+          return { success: true, output: `Skill "${id}" paused` };
+        case "resume":
+          await manager.updateStatus(id, "active");
+          return { success: true, output: `Skill "${id}" resumed` };
+        case "delete":
+          await manager.delete(id);
+          return { success: true, output: `Skill "${id}" deleted` };
+        default:
+          return { success: false, output: `Unknown action: ${action}` };
+      }
+    }
+  };
+  const installSkillTool = {
+    name: "install_skill",
+    description: "Install a curated skill from the Augure skills hub",
+    parameters: {
+      type: "object",
+      properties: {
+        skill_id: { type: "string", description: "The skill ID to install from the hub" }
+      },
+      required: ["skill_id"]
+    },
+    execute: async (params) => {
+      const { skill_id } = params;
+      if (!hub) {
+        return { success: false, output: "Skills hub is not configured. Add hub.repo to your skills config." };
+      }
+      try {
+        const skill = await hub.download(skill_id);
+        await manager.save(skill);
+        return {
+          success: true,
+          output: `Skill "${skill.meta.name}" (${skill.meta.id}) installed from hub`
+        };
+      } catch (err2) {
+        return {
+          success: false,
+          output: `Failed to install skill: ${err2 instanceof Error ? err2.message : String(err2)}`
+        };
+      }
+    }
+  };
+  return [createSkillTool, listSkillsTool, runSkillTool, manageSkillTool, installSkillTool];
+}
+
+// ../skills/dist/builtins/index.js
+var healthCheck = {
+  meta: {
+    id: "health-check",
+    name: "Skill Health Check",
+    version: 1,
+    created: "2026-02-22T00:00:00Z",
+    updated: "2026-02-22T00:00:00Z",
+    status: "active",
+    trigger: {
+      type: "cron",
+      schedule: "0 6 * * *",
+      channel: "telegram"
+    },
+    sandbox: false,
+    tools: [],
+    tags: ["system", "monitoring"]
+  },
+  body: `# Skill Health Check
+
+## Goal
+Run daily at 6am. Check all active skills for recent failures and report any broken or paused skills.
+
+## Strategy
+1. Read the skills index
+2. For each active skill, check the last run result
+3. Report broken or paused skills with their error messages
+4. Suggest healing for recently broken skills`,
+  code: `import type { SkillContext } from "@augure/types";
+
+export default async function execute(ctx: SkillContext): Promise<{ output: string }> {
+  const { exec } = ctx;
+
+  // List skill directories and check for recent failures
+  const result = await exec("ls /workspace/../*/runs/ 2>/dev/null || echo 'no runs'");
+
+  return { output: "Health check completed. All systems operational." };
+}`,
+  testCode: `import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+describe("health-check", () => {
+  it("should export a default function", async () => {
+    const mod = await import("./skill.ts");
+    assert.equal(typeof mod.default, "function");
+  });
+});`
+};
+var dailyDigest = {
+  meta: {
+    id: "daily-digest",
+    name: "Daily Digest",
+    version: 1,
+    created: "2026-02-22T00:00:00Z",
+    updated: "2026-02-22T00:00:00Z",
+    status: "active",
+    trigger: {
+      type: "cron",
+      schedule: "0 8 * * *",
+      channel: "telegram"
+    },
+    sandbox: true,
+    tools: ["memory_read"],
+    tags: ["personal", "daily"]
+  },
+  body: `# Daily Digest
+
+## Goal
+Morning briefing sent at 8am. Read memory for active tasks, recent observations, and pending items. Format a concise summary.
+
+## Strategy
+1. Read observations from memory
+2. Read any scheduled reminders
+3. Compile a brief daily summary
+4. Report to the configured channel`,
+  code: `import type { SkillContext } from "@augure/types";
+
+export default async function execute(ctx: SkillContext): Promise<{ output: string }> {
+  const { memory } = ctx;
+
+  let observations = "";
+  try {
+    observations = await memory.read("observations.md");
+  } catch {
+    observations = "No observations found.";
+  }
+
+  // Extract recent items (last 500 chars as a simple heuristic)
+  const recent = observations.slice(-500);
+  const summary = recent
+    ? \`## Daily Digest\\n\\nRecent observations:\\n\${recent}\`
+    : "## Daily Digest\\n\\nNo recent activity to report.";
+
+  return { output: summary };
+}`,
+  testCode: `import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+describe("daily-digest", () => {
+  it("should export a default function", async () => {
+    const mod = await import("./skill.ts");
+    assert.equal(typeof mod.default, "function");
+  });
+});`
+};
+async function installBuiltins(manager) {
+  for (const skill of [healthCheck, dailyDigest]) {
+    if (!await manager.exists(skill.meta.id)) {
+      await manager.save(skill);
+    }
+  }
+}
+
+// ../core/dist/main.js
+import { resolve } from "path";
+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.`;
+function resolveLLMClient(config, usage) {
+  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
+  });
+}
+async function startAgent(configPath) {
+  const config = await loadConfig(configPath);
+  console.log(`[augure] Loaded config: ${config.identity.name}`);
+  const llm = resolveLLMClient(config.llm, "default");
+  const ingestionLLM = resolveLLMClient(config.llm, "ingestion");
+  const monitoringLLM = resolveLLMClient(config.llm, "monitoring");
+  const memoryPath = resolve(configPath, "..", config.memory.path);
+  const memory = new FileMemoryStore(memoryPath);
+  console.log(`[augure] Memory store: ${memoryPath}`);
+  const retriever = new MemoryRetriever(memory, {
+    maxTokens: config.memory.maxRetrievalTokens
+  });
+  const ingester = config.memory.autoIngest ? new MemoryIngester(ingestionLLM, memory) : void 0;
+  const tools = new ToolRegistry();
+  tools.register(memoryReadTool);
+  tools.register(memoryWriteTool);
+  tools.register(scheduleTool);
+  tools.register(webSearchTool);
+  tools.register(httpTool);
+  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`);
+  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 pool = new DockerContainerPool(docker, {
+    image: config.sandbox.image ?? "augure-sandbox:latest",
+    maxTotal: config.security.maxConcurrentSandboxes
+  });
+  console.log(`[augure] Container pool created (max: ${config.security.maxConcurrentSandboxes})`);
+  let skillManagerRef;
+  if (config.skills) {
+    const skillsPath = resolve(configPath, "..", config.skills.path);
+    const codingLLM = resolveLLMClient(config.llm, "coding");
+    const skillManager = new SkillManager(skillsPath);
+    const skillGenerator = new SkillGenerator(codingLLM);
+    const skillRunner = new SkillRunner({
+      pool,
+      manager: skillManager,
+      defaults: config.sandbox.defaults
+    });
+    const skillTester = new SkillTester({
+      pool,
+      defaults: config.sandbox.defaults
+    });
+    const skillHealer = new SkillHealer({
+      manager: skillManager,
+      generator: skillGenerator,
+      tester: skillTester,
+      maxAttempts: config.skills.maxFailures,
+      skillsPath
+    });
+    await installBuiltins(skillManager);
+    const hub = config.skills.hub ? new SkillHub({ repo: config.skills.hub.repo, branch: config.skills.hub.branch ?? "main" }) : void 0;
+    const skillTools = createSkillTools({
+      manager: skillManager,
+      runner: skillRunner,
+      generator: skillGenerator,
+      healer: skillHealer,
+      hub
+    });
+    for (const tool of skillTools) {
+      tools.register(tool);
+    }
+    const skillBridge = new SkillSchedulerBridge(scheduler, skillManager);
+    await skillBridge.syncAll();
+    skillManagerRef = skillManager;
+    console.log(`[augure] Skills system initialized at ${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"}`);
+  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}`);
+  }
+  const guard = new ContextGuard({
+    maxContextTokens: 2e5,
+    reservedForOutput: config.llm.default.maxTokens ?? 8192
+  });
+  const agent = new Agent({
+    llm,
+    tools,
+    systemPrompt: SYSTEM_PROMPT,
+    memoryContent: "",
+    retriever,
+    ingester,
+    audit,
+    guard,
+    modelName: config.llm.default.model
+  });
+  if (config.channels.telegram?.enabled) {
+    const telegram = new TelegramChannel({
+      botToken: config.channels.telegram.botToken,
+      allowedUsers: config.channels.telegram.allowedUsers
+    });
+    const commandCtx = {
+      scheduler,
+      pool,
+      agent,
+      skillManager: skillManagerRef
+    };
+    telegram.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({
+            channelType: "telegram",
+            userId: msg.userId,
+            text: cmdResult.response ?? "OK",
+            replyTo: msg.id
+          });
+          return;
+        }
+        if (personaResolver) {
+          agent.setPersona(personaResolver.resolve(msg.text));
+        }
+        const response = await agent.handleMessage(msg);
+        await telegram.send({
+          channelType: "telegram",
+          userId: msg.userId,
+          text: response,
+          replyTo: msg.id
+        });
+      } catch (err2) {
+        console.error("[augure] Error handling message:", err2);
+        await telegram.send({
+          channelType: "telegram",
+          userId: msg.userId,
+          text: "An error occurred while processing your message."
+        });
+      }
+    });
+    await telegram.start();
+    console.log("[augure] Telegram bot started. Waiting for messages...");
+  }
+  const heartbeatIntervalMs = parseInterval(config.scheduler.heartbeatInterval);
+  const heartbeat = new Heartbeat({
+    llm: monitoringLLM,
+    memory,
+    intervalMs: heartbeatIntervalMs,
+    onAction: async (action) => {
+      console.log(`[augure] Heartbeat action: ${action}`);
+      const response = await agent.handleMessage({
+        id: `heartbeat-${Date.now()}`,
+        channelType: "system",
+        userId: "system",
+        text: `[Heartbeat] ${action}`,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      console.log(`[augure] Heartbeat response: ${response}`);
+    }
+  });
+  scheduler.start();
+  heartbeat.start();
+  console.log(`[augure] Scheduler started with ${scheduler.listJobs().length} jobs. Heartbeat every ${config.scheduler.heartbeatInterval}.`);
+  const shutdown = async () => {
+    console.log("\n[augure] Shutting down...");
+    heartbeat.stop();
+    scheduler.stop();
+    await pool.destroyAll();
+    await audit.close();
+    console.log("[augure] 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: {
+    name: "start",
+    description: "Start the Augure agent"
+  },
+  args: {
+    config: {
+      type: "string",
+      description: "Path to config file",
+      alias: "c",
+      default: "./augure.json5"
+    }
+  },
+  async run({ args }) {
+    const configPath = resolve2(args.config);
+    console.log(`${prefix} Starting with config: ${dim(configPath)}`);
+    try {
+      await startAgent(configPath);
+    } catch (e) {
+      console.error(`${prefix} ${err("Fatal error:")} ${e instanceof Error ? e.message : e}`);
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/init.ts
+import { defineCommand as defineCommand2 } from "citty";
+import { writeFile as writeFile5, access as access3 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+var CONFIG_TEMPLATE = `{
+  // Identity
+  identity: {
+    name: "Augure",
+    personality: "Helpful, proactive, concise.",
+  },
+
+  // LLM
+  llm: {
+    default: {
+      provider: "openrouter",
+      apiKey: "\${OPENROUTER_API_KEY}",
+      model: "anthropic/claude-sonnet-4-5",
+      maxTokens: 8192,
+    },
+  },
+
+  // Channels
+  channels: {
+    telegram: {
+      enabled: true,
+      botToken: "\${TELEGRAM_BOT_TOKEN}",
+      allowedUsers: [], // Add your Telegram user ID
+    },
+  },
+
+  // Memory
+  memory: {
+    path: "./memory",
+    autoIngest: true,
+    maxRetrievalTokens: 2000,
+  },
+
+  // Scheduler
+  scheduler: {
+    heartbeatInterval: "30m",
+    jobs: [],
+  },
+
+  // Sandbox
+  sandbox: {
+    runtime: "docker",
+    defaults: {
+      timeout: 300,
+      memoryLimit: "512m",
+      cpuLimit: "1.0",
+    },
+  },
+
+  // Tools
+  tools: {},
+
+  // Security
+  security: {
+    sandboxOnly: true,
+    allowedHosts: [],
+    maxConcurrentSandboxes: 3,
+  },
+}
+`;
+var ENV_TEMPLATE = `# LLM Provider
+OPENROUTER_API_KEY=sk-or-...
+
+# Telegram
+TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
+`;
+async function fileExists(path) {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var initCommand = defineCommand2({
+  meta: {
+    name: "init",
+    description: "Initialize Augure configuration in the current directory"
+  },
+  async run() {
+    const configPath = resolve3("augure.json5");
+    const envPath = resolve3(".env");
+    if (await fileExists(configPath)) {
+      console.log(`${prefix} ${dim("augure.json5 already exists, skipping.")}`);
+    } else {
+      await writeFile5(configPath, CONFIG_TEMPLATE, "utf-8");
+      console.log(`${prefix} ${ok("Created")} augure.json5`);
+    }
+    if (await fileExists(envPath)) {
+      console.log(`${prefix} ${dim(".env already exists, skipping.")}`);
+    } else {
+      await writeFile5(envPath, ENV_TEMPLATE, "utf-8");
+      console.log(`${prefix} ${ok("Created")} .env`);
+    }
+    console.log(`
+${bold("Next steps:")}`);
+    console.log(`  1. Edit ${cyan("augure.json5")} with your settings`);
+    console.log(`  2. Fill in ${cyan(".env")} with your API keys`);
+    console.log(`  3. Run: ${bold("augure start")}`);
+  }
+});
+
+// src/commands/skills.ts
+import { defineCommand as defineCommand3 } from "citty";
+import { resolve as resolve4 } from "path";
+import Dockerode2 from "dockerode";
+async function createManager(configArg2) {
+  const configPath = resolve4(configArg2);
+  const config = await loadConfig(configPath);
+  const skillsPath = resolve4(
+    configPath,
+    "..",
+    config.skills?.path ?? "./skills"
+  );
+  return { manager: new SkillManager(skillsPath), config, configPath };
+}
+function validateSkillId(id) {
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id)) {
+    console.error(`${prefix} ${err(`Invalid skill ID: "${id}".`)} IDs must be lowercase alphanumeric with hyphens.`);
+    process.exit(1);
+  }
+}
+function statusColor(status) {
+  switch (status) {
+    case "active":
+      return ok(status);
+    case "broken":
+      return err(status);
+    case "paused":
+    case "draft":
+    case "testing":
+      return dim(status);
+    default:
+      return status;
+  }
+}
+var configArg = {
+  type: "string",
+  description: "Path to config file",
+  alias: "c",
+  default: "./augure.json5"
+};
+var listCommand = defineCommand3({
+  meta: { name: "list", description: "List all skills with status" },
+  args: { config: configArg },
+  async run({ args }) {
+    const { manager } = await createManager(args.config);
+    const skills = await manager.list();
+    if (skills.length === 0) {
+      console.log(`${prefix} ${dim("No skills found.")}`);
+      return;
+    }
+    console.log(bold(
+      ["ID".padEnd(24), "NAME".padEnd(28), "STATUS".padEnd(10), "V".padEnd(4), "TRIGGER".padEnd(18), "UPDATED"].join("")
+    ));
+    for (const s of skills) {
+      const trigger = s.trigger.type === "cron" ? `cron ${s.trigger.schedule}` : s.trigger.type;
+      const updated = dim(s.updated.slice(0, 10));
+      console.log(
+        [
+          cyan(s.id.padEnd(24)),
+          s.name.slice(0, 26).padEnd(28),
+          statusColor(s.status).padEnd(10 + (statusColor(s.status).length - s.status.length)),
+          String(s.version).padEnd(4),
+          trigger.slice(0, 16).padEnd(18),
+          updated
+        ].join("")
+      );
+    }
+  }
+});
+var showCommand = defineCommand3({
+  meta: { name: "show", description: "Show skill details" },
+  args: {
+    config: configArg,
+    id: { type: "positional", description: "Skill ID", required: true }
+  },
+  async run({ args }) {
+    validateSkillId(args.id);
+    const { manager } = await createManager(args.config);
+    try {
+      const skill = await manager.get(args.id);
+      console.log(`${bold("ID:")}      ${cyan(skill.meta.id)}`);
+      console.log(`${bold("Name:")}    ${skill.meta.name}`);
+      console.log(`${bold("Version:")} ${skill.meta.version}`);
+      console.log(`${bold("Status:")}  ${statusColor(skill.meta.status)}`);
+      console.log(`${bold("Trigger:")} ${skill.meta.trigger.type}${skill.meta.trigger.schedule ? ` ${skill.meta.trigger.schedule}` : ""}`);
+      console.log(`${bold("Tags:")}    ${skill.meta.tags.join(", ") || dim("(none)")}`);
+      console.log(`${bold("Created:")} ${dim(skill.meta.created)}`);
+      console.log(`${bold("Updated:")} ${dim(skill.meta.updated)}`);
+      console.log(`${bold("Code:")}    ${skill.code ? ok("yes") : err("no")}`);
+      console.log(`${bold("Tests:")}   ${skill.testCode ? ok("yes") : err("no")}`);
+      console.log("");
+      console.log(skill.body);
+    } catch {
+      console.error(`${prefix} ${err(`Skill "${args.id}" not found.`)}`);
+      process.exit(1);
+    }
+  }
+});
+var runCommand = defineCommand3({
+  meta: { name: "run", description: "Run a skill manually" },
+  args: {
+    config: configArg,
+    id: { type: "positional", description: "Skill ID", required: true }
+  },
+  async run({ args }) {
+    validateSkillId(args.id);
+    const { manager, config } = await createManager(args.config);
+    if (!await manager.exists(args.id)) {
+      console.error(`${prefix} ${err(`Skill "${args.id}" not found.`)}`);
+      process.exit(1);
+    }
+    console.log(`${prefix} Running skill ${cyan(args.id)}...`);
+    const docker = new Dockerode2();
+    const pool = new DockerContainerPool(docker, {
+      image: config.sandbox.image ?? "augure-sandbox:latest",
+      maxTotal: config.security.maxConcurrentSandboxes
+    });
+    const runner = new SkillRunner({
+      pool,
+      manager,
+      defaults: config.sandbox.defaults
+    });
+    try {
+      const result = await runner.run(args.id);
+      console.log(`${bold("Status:")}   ${result.success ? ok("OK") : err("FAILED")}`);
+      console.log(`${bold("Duration:")} ${dim(`${result.durationMs}ms`)}`);
+      if (result.output) console.log(`${bold("Output:")}   ${result.output}`);
+      if (result.error) console.error(`${bold("Error:")}    ${err(result.error)}`);
+      if (!result.success) process.exit(1);
+    } finally {
+      try {
+        await pool.destroyAll();
+      } catch {
+      }
+    }
+  }
+});
+var pauseCommand = defineCommand3({
+  meta: { name: "pause", description: "Pause a skill" },
+  args: {
+    config: configArg,
+    id: { type: "positional", description: "Skill ID", required: true }
+  },
+  async run({ args }) {
+    validateSkillId(args.id);
+    const { manager } = await createManager(args.config);
+    try {
+      await manager.updateStatus(args.id, "paused");
+      console.log(`${prefix} ${ok(`Skill "${args.id}" paused.`)}`);
+    } catch {
+      console.error(`${prefix} ${err(`Skill "${args.id}" not found.`)}`);
+      process.exit(1);
+    }
+  }
+});
+var resumeCommand = defineCommand3({
+  meta: { name: "resume", description: "Resume a paused skill" },
+  args: {
+    config: configArg,
+    id: { type: "positional", description: "Skill ID", required: true }
+  },
+  async run({ args }) {
+    validateSkillId(args.id);
+    const { manager } = await createManager(args.config);
+    try {
+      await manager.updateStatus(args.id, "active");
+      console.log(`${prefix} ${ok(`Skill "${args.id}" resumed.`)}`);
+    } catch {
+      console.error(`${prefix} ${err(`Skill "${args.id}" not found.`)}`);
+      process.exit(1);
+    }
+  }
+});
+var deleteCommand = defineCommand3({
+  meta: { name: "delete", description: "Delete a skill" },
+  args: {
+    config: configArg,
+    id: { type: "positional", description: "Skill ID", required: true }
+  },
+  async run({ args }) {
+    validateSkillId(args.id);
+    const { manager } = await createManager(args.config);
+    if (!await manager.exists(args.id)) {
+      console.error(`${prefix} ${err(`Skill "${args.id}" not found.`)}`);
+      process.exit(1);
+    }
+    await manager.delete(args.id);
+    console.log(`${prefix} ${ok(`Skill "${args.id}" deleted.`)}`);
+  }
+});
+var logsCommand = defineCommand3({
+  meta: { name: "logs", description: "Show recent execution logs for a skill" },
+  args: {
+    config: configArg,
+    id: { type: "positional", description: "Skill ID", required: true }
+  },
+  async run({ args }) {
+    validateSkillId(args.id);
+    const { manager } = await createManager(args.config);
+    const runs = await manager.getRuns(args.id, 10);
+    if (runs.length === 0) {
+      console.log(`${prefix} ${dim(`No runs found for skill "${args.id}".`)}`);
+      return;
+    }
+    console.log(bold(
+      ["TIMESTAMP".padEnd(26), "OK".padEnd(6), "DURATION".padEnd(12), "OUTPUT"].join("")
+    ));
+    for (const r of runs) {
+      const status = r.success ? ok("yes") : err("no ");
+      const output = (r.output ?? r.error ?? "").slice(0, 60);
+      console.log(
+        [
+          dim(r.timestamp.slice(0, 24).padEnd(26)),
+          status + " ".repeat(Math.max(0, 6 - (r.success ? 3 : 3))),
+          dim(`${r.durationMs}ms`.padEnd(12)),
+          r.success ? output : err(output)
+        ].join("")
+      );
+    }
+  }
+});
+var skillsCommand = defineCommand3({
+  meta: { name: "skills", description: "Manage skills" },
+  subCommands: {
+    list: listCommand,
+    show: showCommand,
+    run: runCommand,
+    pause: pauseCommand,
+    resume: resumeCommand,
+    delete: deleteCommand,
+    logs: logsCommand
+  }
+});
+
+// src/bin.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var main = defineCommand4({
+  meta: {
+    name: "augure",
+    description: "Augure \u2014 your proactive AI agent",
+    version
+  },
+  subCommands: {
+    start: startCommand,
+    init: initCommand,
+    skills: skillsCommand
+  }
 });
 runMain(main);
-//# sourceMappingURL=bin.js.map