augure 0.5.0 → 0.6.0

package/dist/bin.js

@@ -135,6 +135,11 @@ var AppConfigSchema = z.object({
       checkInterval: z.string().min(1).default("24h"),
       notifyChannel: z.string().min(1).default("telegram")
     }).optional()
+  }).optional(),
+  codeMode: z.object({
+    runtime: z.enum(["vm", "docker", "auto"]).default("auto"),
+    timeout: z.number().int().positive().default(30),
+    memoryLimit: z.number().int().positive().default(128)
   }).optional()
 });
 function interpolateEnvVars(raw) {
@@ -153,19 +158,33 @@ async function loadConfig(path) {
   return AppConfigSchema.parse(parsed);
 }
 
+// ../types/dist/logger.js
+var noop = () => {
+};
+var noopLogger = {
+  debug: noop,
+  info: noop,
+  warn: noop,
+  error: noop,
+  child: () => noopLogger
+};
+
 // ../core/dist/llm.js
 var OpenRouterClient = class {
   apiKey;
   model;
   maxTokens;
   baseUrl;
+  log;
   constructor(config) {
     this.apiKey = config.apiKey;
     this.model = config.model;
     this.maxTokens = config.maxTokens;
     this.baseUrl = config.baseUrl ?? "https://openrouter.ai/api/v1";
+    this.log = config.logger ?? noopLogger;
   }
   async chat(messages, tools) {
+    this.log.debug(`Request: model=${this.model} messages=${messages.length} tools=${tools?.length ?? 0}`);
     const response = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
@@ -199,6 +218,7 @@ var OpenRouterClient = class {
     }
     const data = await response.json();
     const choice = data.choices[0];
+    this.log.debug(`Response: ${response.status} ${data.usage.prompt_tokens}+${data.usage.completion_tokens} tokens`);
     return {
       content: choice.message.content ?? "",
       toolCalls: (choice.message.tool_calls ?? []).map((tc) => {
@@ -206,7 +226,7 @@ var OpenRouterClient = class {
         try {
           args = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
         } catch {
-          console.error(`[augure] Failed to parse tool call arguments for ${tc.function.name}:`, tc.function.arguments);
+          this.log.warn(`Failed to parse tool call arguments for ${tc.function.name}`);
         }
         return { id: tc.id, name: tc.function.name, arguments: args };
       }),
@@ -222,6 +242,19 @@ var OpenRouterClient = class {
 function assembleContext(input) {
   const { systemPrompt, memoryContent, conversationHistory, persona } = input;
   let system = systemPrompt;
+  const now = /* @__PURE__ */ new Date();
+  const humanDate = new Intl.DateTimeFormat("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZoneName: "short"
+  }).format(now);
+  system += `
+
+Current date and time: ${now.toISOString()} (${humanDate})`;
   if (persona) {
     system += `
 
@@ -239,6 +272,403 @@ ${memoryContent}`;
   return messages;
 }
 
+// ../code-mode/dist/typegen.js
+var JSON_TO_TS = {
+  string: "string",
+  number: "number",
+  integer: "number",
+  boolean: "boolean",
+  array: "unknown[]",
+  object: "Record<string, unknown>"
+};
+function sanitizeName(name) {
+  return name.replace(/[-. ]/g, "_");
+}
+function toPascalCase(name) {
+  return sanitizeName(name).split("_").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function mapType(schema) {
+  const t = schema.type;
+  if (schema.enum) {
+    return schema.enum.map((v) => `"${v}"`).join(" | ");
+  }
+  return JSON_TO_TS[t ?? "string"] ?? "unknown";
+}
+function generateDeclarations(registry) {
+  const tools = registry.list();
+  const blocks = [];
+  const apiEntries = [];
+  for (const tool of tools) {
+    const safeName = sanitizeName(tool.name);
+    const interfaceName = `${toPascalCase(tool.name)}Input`;
+    const params = tool.parameters;
+    const properties = params.properties ?? {};
+    const required = new Set(params.required ?? []);
+    const fields = [];
+    for (const [key, schema] of Object.entries(properties)) {
+      const optional = required.has(key) ? "" : "?";
+      const tsType = mapType(schema);
+      const desc = schema.description;
+      if (desc) {
+        fields.push(`  /** ${desc} */
+  ${key}${optional}: ${tsType};`);
+      } else {
+        fields.push(`  ${key}${optional}: ${tsType};`);
+      }
+    }
+    blocks.push(`interface ${interfaceName} {
+${fields.join("\n")}
+}`);
+    apiEntries.push(`  /** ${tool.description} */
+  ${safeName}: (input: ${interfaceName}) => Promise<{ success: boolean; output: string }>;`);
+  }
+  const apiBlock = `declare const api: {
+${apiEntries.join("\n")}
+};`;
+  return [...blocks, "", apiBlock].join("\n");
+}
+
+// ../code-mode/dist/bridge.js
+function createBridgeHandler(registry) {
+  return async (toolName, input) => {
+    try {
+      return await registry.execute(toolName, input);
+    } catch (err2) {
+      return {
+        success: false,
+        output: `Bridge error calling ${toolName}: ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+  };
+}
+function generateHarnessCode(userCode) {
+  return `
+const __logs = [];
+const __originalLog = console.log;
+const __originalWarn = console.warn;
+const __originalError = console.error;
+console.log = (...args) => __logs.push(args.map(String).join(" "));
+console.warn = (...args) => __logs.push("[warn] " + args.map(String).join(" "));
+console.error = (...args) => __logs.push("[error] " + args.map(String).join(" "));
+
+let __toolCalls = 0;
+
+const api = new Proxy({}, {
+  get: (_target, toolName) => {
+    return async (input) => {
+      __toolCalls++;
+      return await __bridge(String(toolName), input);
+    };
+  }
+});
+
+async function __run() {
+  ${userCode}
+}
+
+try {
+  const __result = await __run();
+  __originalLog(JSON.stringify({
+    success: true,
+    output: __result,
+    logs: __logs,
+    toolCalls: __toolCalls,
+  }));
+} catch (err) {
+  __originalLog(JSON.stringify({
+    success: false,
+    error: err.message ?? String(err),
+    logs: __logs,
+    toolCalls: __toolCalls,
+  }));
+}
+`;
+}
+
+// ../code-mode/dist/vm-sandbox.js
+import { createContext, runInContext } from "vm";
+import { transform } from "esbuild";
+var VmExecutor = class {
+  registry;
+  config;
+  constructor(registry, config) {
+    this.registry = registry;
+    this.config = config;
+  }
+  async execute(code) {
+    const start = performance.now();
+    try {
+      const harnessTs = generateHarnessCode(code);
+      const { code: harnessJs } = await transform(harnessTs, {
+        loader: "ts",
+        target: "es2024"
+      });
+      const bridgeHandler = createBridgeHandler(this.registry);
+      const consoleLogs = [];
+      const captureConsole = {
+        log: (...args) => consoleLogs.push(args.map(String).join(" ")),
+        warn: (...args) => consoleLogs.push("[warn] " + args.map(String).join(" ")),
+        error: (...args) => consoleLogs.push("[error] " + args.map(String).join(" "))
+      };
+      const context = createContext({
+        console: captureConsole,
+        __bridge: bridgeHandler,
+        JSON,
+        String,
+        Number,
+        Boolean,
+        Array,
+        Object,
+        Error,
+        Promise,
+        Map,
+        Set,
+        parseInt,
+        parseFloat,
+        isNaN,
+        isFinite,
+        setTimeout,
+        Date,
+        RegExp,
+        Math,
+        Symbol,
+        Uint8Array,
+        TextEncoder,
+        TextDecoder,
+        Buffer,
+        URL,
+        URLSearchParams
+      });
+      const wrappedCode = `(async () => { ${harnessJs} })()`;
+      const timeoutPromise = new Promise((_, reject) => {
+        const timer = setTimeout(() => reject(new Error("Timeout: code execution exceeded time limit")), this.config.timeout);
+        timer.unref?.();
+      });
+      const resultPromise = runInContext(wrappedCode, context, {
+        timeout: this.config.timeout
+      });
+      await Promise.race([resultPromise, timeoutPromise]);
+      const durationMs = performance.now() - start;
+      const lastLine = consoleLogs[consoleLogs.length - 1];
+      if (!lastLine) {
+        return {
+          success: false,
+          output: void 0,
+          logs: consoleLogs,
+          error: "No output produced by code execution",
+          durationMs,
+          toolCalls: 0
+        };
+      }
+      const parsed = JSON.parse(lastLine);
+      return {
+        success: parsed.success,
+        output: parsed.output,
+        logs: parsed.logs,
+        error: parsed.error,
+        durationMs,
+        toolCalls: parsed.toolCalls
+      };
+    } catch (err2) {
+      const durationMs = performance.now() - start;
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        error: err2 instanceof Error ? err2.message : String(err2),
+        durationMs,
+        toolCalls: 0
+      };
+    }
+  }
+};
+
+// ../code-mode/dist/docker-sandbox.js
+var DOCKER_HARNESS = `
+import { readFile } from "node:fs/promises";
+
+const __logs = [];
+const __originalLog = console.log;
+console.log = (...args) => __logs.push(args.map(String).join(" "));
+console.warn = (...args) => __logs.push("[warn] " + args.map(String).join(" "));
+console.error = (...args) => __logs.push("[error] " + args.map(String).join(" "));
+
+let __toolCalls = 0;
+
+const api = new Proxy({}, {
+  get: (_target, toolName) => {
+    return async () => {
+      __toolCalls++;
+      return { success: false, output: "Tool calls not yet supported in Docker executor" };
+    };
+  }
+});
+
+const __userCode = await readFile("/workspace/user-code.js", "utf-8");
+const __fn = new Function("api", "__logs",
+  "return (async () => { " + __userCode + " })();"
+);
+
+try {
+  const __result = await __fn(api, __logs);
+  __originalLog(JSON.stringify({
+    success: true,
+    output: __result,
+    logs: __logs,
+    toolCalls: __toolCalls,
+  }));
+} catch (err) {
+  __originalLog(JSON.stringify({
+    success: false,
+    error: err.message ?? String(err),
+    logs: __logs,
+    toolCalls: __toolCalls,
+  }));
+}
+`;
+var DockerExecutor = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async execute(code) {
+    const start = Date.now();
+    let container;
+    try {
+      container = await this.config.pool.acquire({
+        trust: "sandboxed",
+        timeout: this.config.timeout,
+        memory: this.config.memoryLimit,
+        cpu: this.config.cpuLimit
+      });
+    } catch (err2) {
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        toolCalls: 0,
+        error: `Failed to acquire container: ${err2 instanceof Error ? err2.message : String(err2)}`,
+        durationMs: Date.now() - start
+      };
+    }
+    try {
+      await container.exec("mkdir -p /workspace");
+      const codeB64 = Buffer.from(code).toString("base64");
+      await container.exec(`sh -c 'echo "${codeB64}" | base64 -d > /workspace/user-code.js'`);
+      const harnessB64 = Buffer.from(DOCKER_HARNESS).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.timeout,
+        cwd: "/workspace"
+      });
+      if (execResult.exitCode === 0 && execResult.stdout.trim()) {
+        try {
+          const lastLine = execResult.stdout.trim().split("\n").pop();
+          const parsed = JSON.parse(lastLine);
+          return {
+            success: parsed.success,
+            output: parsed.output,
+            logs: parsed.logs ?? [],
+            error: parsed.error,
+            durationMs: Date.now() - start,
+            toolCalls: parsed.toolCalls ?? 0
+          };
+        } catch {
+          return {
+            success: true,
+            output: execResult.stdout.trim(),
+            logs: [],
+            durationMs: Date.now() - start,
+            toolCalls: 0
+          };
+        }
+      }
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        toolCalls: 0,
+        error: execResult.stderr || execResult.stdout || "Unknown error",
+        durationMs: Date.now() - start
+      };
+    } catch (err2) {
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        toolCalls: 0,
+        error: err2 instanceof Error ? err2.message : String(err2),
+        durationMs: Date.now() - start
+      };
+    } finally {
+      await this.config.pool.release(container);
+    }
+  }
+};
+
+// ../code-mode/dist/tool.js
+function createCodeModeTool(registry, executor) {
+  const declarations = generateDeclarations(registry);
+  return {
+    name: "execute_code",
+    description: `Execute TypeScript code with access to the agent's APIs. Write the body of an async function.
+
+Available APIs:
+
+\`\`\`typescript
+${declarations}
+\`\`\`
+
+Each API call returns { success: boolean, output: string }.
+Use console.log() for intermediate output. Return your final result.`,
+    parameters: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The body of an async TypeScript function. Use the 'api' object to call tools."
+        }
+      },
+      required: ["code"]
+    },
+    execute: async (params) => {
+      const { code } = params;
+      const result = await executor.execute(code);
+      if (result.success) {
+        const parts = [];
+        if (result.logs.length > 0) {
+          parts.push(`[logs]
+${result.logs.join("\n")}`);
+        }
+        parts.push(typeof result.output === "string" ? result.output : JSON.stringify(result.output));
+        return { success: true, output: parts.join("\n\n") };
+      }
+      return {
+        success: false,
+        output: result.error ?? "Code execution failed"
+      };
+    }
+  };
+}
+
+// ../code-mode/dist/auto-executor.js
+var AutoExecutor = class {
+  primary;
+  fallback;
+  constructor(primary, fallback) {
+    this.primary = primary;
+    this.fallback = fallback;
+  }
+  async execute(code) {
+    try {
+      const result = await this.primary.execute(code);
+      return result;
+    } catch {
+      return this.fallback.execute(code);
+    }
+  }
+};
+
 // ../core/dist/audit.js
 import { appendFile, mkdir } from "fs/promises";
 import { join } from "path";
@@ -249,13 +679,15 @@ function summarize(text, maxLen = 200) {
 }
 var FileAuditLogger = class {
   basePath;
+  logger;
   pendingWrite = Promise.resolve();
   initialized = false;
-  constructor(basePath) {
+  constructor(basePath, logger) {
     this.basePath = basePath;
+    this.logger = logger ?? noopLogger;
   }
   log(entry) {
-    this.pendingWrite = this.pendingWrite.then(() => this.writeEntry(entry)).catch((err2) => console.error("[augure] Audit write error:", err2));
+    this.pendingWrite = this.pendingWrite.then(() => this.writeEntry(entry)).catch((err2) => this.logger.error("Audit write error:", err2));
   }
   async close() {
     await this.pendingWrite;
@@ -281,10 +713,12 @@ var NullAuditLogger = class {
 // ../core/dist/agent.js
 var Agent = class {
   config;
+  log;
   conversations = /* @__PURE__ */ new Map();
   state = "running";
   constructor(config) {
     this.config = config;
+    this.log = config.logger ?? noopLogger;
   }
   getState() {
     return this.state;
@@ -317,6 +751,19 @@ var Agent = class {
     const maxLoops = this.config.maxToolLoops ?? 10;
     let loopCount = 0;
     const toolSchemas = this.config.tools.toFunctionSchemas();
+    let effectiveSchemas = toolSchemas;
+    let codeModeTool;
+    if (this.config.codeModeExecutor) {
+      codeModeTool = createCodeModeTool(this.config.tools, this.config.codeModeExecutor);
+      effectiveSchemas = [{
+        type: "function",
+        function: {
+          name: codeModeTool.name,
+          description: codeModeTool.description,
+          parameters: codeModeTool.parameters
+        }
+      }];
+    }
     while (loopCount < maxLoops) {
       const messages = assembleContext({
         systemPrompt: this.config.systemPrompt,
@@ -324,12 +771,14 @@ var Agent = class {
         conversationHistory: history,
         persona: this.config.persona
       });
-      const response = await this.config.llm.chat(messages, toolSchemas);
+      this.log.debug(`LLM call #${loopCount + 1} (${messages.length} messages)`);
+      const response = await this.config.llm.chat(messages, effectiveSchemas);
       if (response.toolCalls.length === 0) {
         history.push({
           role: "assistant",
           content: response.content
         });
+        this.log.debug(`Response: ${response.usage.inputTokens}+${response.usage.outputTokens} tokens, ${Date.now() - start}ms`);
         if (this.config.audit) {
           this.config.audit.log({
             ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -347,7 +796,7 @@ var Agent = class {
           });
         }
         if (this.config.ingester) {
-          this.config.ingester.ingest(history).catch((err2) => console.error("[augure] Ingestion error:", err2));
+          this.config.ingester.ingest(history).catch((err2) => this.log.error("Ingestion error:", err2));
         }
         return response.content;
       }
@@ -358,7 +807,14 @@ var Agent = class {
       });
       for (const toolCall of response.toolCalls) {
         const toolStart = Date.now();
-        const result = await this.config.tools.execute(toolCall.name, toolCall.arguments);
+        this.log.debug(`Tool: ${toolCall.name}`);
+        let result;
+        if (codeModeTool && toolCall.name === "execute_code") {
+          result = await codeModeTool.execute(toolCall.arguments, {});
+        } else {
+          result = await this.config.tools.execute(toolCall.name, toolCall.arguments);
+        }
+        this.log.debug(`Tool ${toolCall.name}: ${result.success ? "ok" : "fail"} (${Date.now() - toolStart}ms)`);
         history.push({
           role: "tool",
           content: result.output,
@@ -566,6 +1022,56 @@ var ContextGuard = class {
   }
 };
 
+// ../core/dist/logger.js
+import { styleText } from "util";
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+function tag(level) {
+  switch (level) {
+    case "debug":
+      return styleText("magenta", "DBG");
+    case "info":
+      return styleText("cyan", "INF");
+    case "warn":
+      return styleText("yellow", "WRN");
+    case "error":
+      return styleText("red", "ERR");
+  }
+}
+function createLogger(opts = {}) {
+  const min = LEVELS[opts.level ?? "info"];
+  const scope = opts.scope;
+  function emit(level, msg, args) {
+    if (LEVELS[level] < min)
+      return;
+    const ts = styleText("dim", (/* @__PURE__ */ new Date()).toISOString().slice(11, 23));
+    const lvl = tag(level);
+    const sc = scope ? ` ${styleText("dim", scope)}` : "";
+    const prefix2 = `${styleText("yellow", "\u25B2")} ${ts} ${lvl}${sc}`;
+    const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+    if (args.length > 0) {
+      fn(prefix2, msg, ...args);
+    } else {
+      fn(prefix2, msg);
+    }
+  }
+  return {
+    debug: (msg, ...args) => emit("debug", msg, args),
+    info: (msg, ...args) => emit("info", msg, args),
+    warn: (msg, ...args) => emit("warn", msg, args),
+    error: (msg, ...args) => emit("error", msg, args),
+    child: (childScope) => createLogger({
+      level: opts.level,
+      scope: scope ? `${scope}:${childScope}` : childScope
+    })
+  };
+}
+
 // ../channels/dist/telegram/telegram.js
 import { Bot } from "grammy";
 
@@ -786,11 +1292,13 @@ var TelegramChannel = class {
   allowedUsers;
   handlers = [];
   sendPipeline;
+  log;
   constructor(config) {
+    this.log = config.logger ?? noopLogger;
     this.bot = new Bot(config.botToken);
     this.allowedUsers = new Set(config.allowedUsers);
     this.bot.catch((err2) => {
-      console.error("[augure:telegram] Bot error:", err2.message ?? err2);
+      this.log.error("Bot error:", err2.message ?? err2);
     });
     this.bot.on("message:text", async (ctx) => {
       const userId = ctx.from.id;
@@ -819,7 +1327,7 @@ var TelegramChannel = class {
         ...replyOpts
       }), { maxRetries: 3, baseDelayMs: 500 }).catch(async () => {
         await this.bot.api.sendMessage(Number(msg.userId), msg.text, replyOpts).catch((fallbackErr) => {
-          console.error("[augure:telegram] Fallback send also failed:", fallbackErr);
+          this.log.error("Fallback send also failed:", fallbackErr);
           throw fallbackErr;
         });
       });
@@ -830,7 +1338,7 @@ var TelegramChannel = class {
     return this.allowedUsers.has(userId);
   }
   handleRejected(userId, unixTimestamp, rejectMessage) {
-    console.warn(`[augure:telegram] Rejected message from unauthorized user ${userId} at ${new Date(unixTimestamp * 1e3).toISOString()}`);
+    this.log.warn(`Rejected message from unauthorized user ${userId} at ${new Date(unixTimestamp * 1e3).toISOString()}`);
     if (rejectMessage) {
       this.bot.api.sendMessage(userId, rejectMessage).catch(() => {
       });
@@ -864,14 +1372,27 @@ var ToolRegistry = class {
     return Array.from(this.tools.values());
   }
   toFunctionSchemas() {
-    return this.list().map((tool) => ({
-      type: "function",
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.parameters
+    return this.list().map((tool) => {
+      let description = tool.description;
+      if (tool.configCheck && this.context) {
+        try {
+          const warning = tool.configCheck(this.context);
+          if (warning) {
+            description += `
+[NOT CONFIGURED] ${warning}`;
+          }
+        } catch {
+        }
       }
-    }));
+      return {
+        type: "function",
+        function: {
+          name: tool.name,
+          description,
+          parameters: tool.parameters
+        }
+      };
+    });
   }
   async execute(name, params) {
     const tool = this.tools.get(name);
@@ -1011,10 +1532,54 @@ var scheduleTool = {
   }
 };
 
+// ../tools/dist/datetime.js
+var datetimeTool = {
+  name: "datetime",
+  description: "Get the current date and time, optionally in a specific timezone",
+  parameters: {
+    type: "object",
+    properties: {
+      timezone: {
+        type: "string",
+        description: "IANA timezone (e.g. 'Europe/Paris', 'America/New_York'). Defaults to the system timezone."
+      }
+    }
+  },
+  execute: async (params) => {
+    const { timezone } = params;
+    const now = /* @__PURE__ */ new Date();
+    const options = {
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      timeZoneName: "longOffset"
+    };
+    if (timezone) {
+      options.timeZone = timezone;
+    }
+    try {
+      const formatted = new Intl.DateTimeFormat("en-US", options).format(now);
+      return {
+        success: true,
+        output: `${formatted}
+ISO 8601 (UTC): ${now.toISOString()}
+Unix timestamp: ${Math.floor(now.getTime() / 1e3)}`
+      };
+    } catch {
+      return { success: false, output: `Invalid timezone: ${timezone}` };
+    }
+  }
+};
+
 // ../tools/dist/web-search.js
 var webSearchTool = {
   name: "web_search",
   description: "Search the web using the configured search provider (Tavily, Exa, or SearXNG)",
+  configCheck: (ctx) => ctx.config.tools?.webSearch ? null : "This tool requires configuration. See https://augure.dev/docs/tools/web-search",
   parameters: {
     type: "object",
     properties: {
@@ -1226,6 +1791,273 @@ ${text}`;
 // ../tools/dist/email.js
 import { ImapFlow } from "imapflow";
 import { createTransport } from "nodemailer";
+var MAX_BODY_CHARS = 4e3;
+function stripHtml(html) {
+  return html.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n\n").replace(/<\/div>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\n{3,}/g, "\n\n").trim();
+}
+function findTextPart(structure) {
+  if (structure.type === "text/plain" && structure.part) {
+    return { part: structure.part, isHtml: false };
+  }
+  if (structure.type === "text/html" && structure.part) {
+    return { part: structure.part, isHtml: true };
+  }
+  if (structure.childNodes) {
+    let htmlFallback = null;
+    for (const child of structure.childNodes) {
+      const found = findTextPart(child);
+      if (found && !found.isHtml)
+        return found;
+      if (found && found.isHtml)
+        htmlFallback = found;
+    }
+    return htmlFallback;
+  }
+  return null;
+}
+async function withImapClient(config, fn) {
+  const client = new ImapFlow({
+    host: config.host,
+    port: config.port,
+    secure: config.port === 993,
+    auth: { user: config.user, pass: config.password },
+    logger: false
+  });
+  let connected = false;
+  try {
+    await client.connect();
+    connected = true;
+    return await fn(client);
+  } finally {
+    if (connected) {
+      await client.logout();
+    }
+  }
+}
+function formatSummaries(emails) {
+  if (emails.length === 0)
+    return "No emails found.";
+  return emails.map((e, i) => `${i + 1}. ${e.seen ? "" : "[UNREAD] "}UID:${e.uid} Subject: ${e.subject} | From: ${e.from} | Date: ${e.date}`).join("\n");
+}
+function extractAddress(addr) {
+  if (!addr)
+    return "unknown";
+  if (Array.isArray(addr)) {
+    const first = addr[0];
+    if (first && typeof first === "object" && "address" in first) {
+      return first.address;
+    }
+    return String(first ?? "unknown");
+  }
+  if (typeof addr === "object" && "address" in addr) {
+    return addr.address;
+  }
+  return String(addr);
+}
+async function handleList(params, imapConfig) {
+  const folder = params.folder ?? "INBOX";
+  const limit = params.limit ?? 10;
+  return withImapClient(imapConfig, async (client) => {
+    const lock = await client.getMailboxLock(folder);
+    try {
+      const status = client.mailbox;
+      if (!status || status.exists === 0)
+        return "Mailbox is empty.";
+      const start = Math.max(1, status.exists - limit + 1);
+      const emails = [];
+      for await (const msg of client.fetch(`${start}:*`, {
+        envelope: true,
+        flags: true
+      })) {
+        emails.push({
+          uid: msg.uid,
+          subject: msg.envelope?.subject ?? "(no subject)",
+          from: extractAddress(msg.envelope?.from),
+          date: msg.envelope?.date?.toISOString() ?? "unknown",
+          seen: msg.flags?.has("\\Seen") ?? false
+        });
+      }
+      return formatSummaries(emails.slice(-limit));
+    } finally {
+      lock.release();
+    }
+  });
+}
+async function handleRead(params, imapConfig) {
+  const folder = params.folder ?? "INBOX";
+  return withImapClient(imapConfig, async (client) => {
+    const lock = await client.getMailboxLock(folder);
+    try {
+      const msg = await client.fetchOne(String(params.uid), {
+        envelope: true,
+        bodyStructure: true,
+        flags: true,
+        uid: true
+      });
+      if (!msg)
+        return `No email found with UID ${params.uid}.`;
+      let bodyText = "";
+      const textPart = msg.bodyStructure ? findTextPart(msg.bodyStructure) : null;
+      if (textPart) {
+        const { content } = await client.download(String(params.uid), textPart.part, {
+          uid: true
+        });
+        const chunks = [];
+        for await (const chunk of content) {
+          chunks.push(Buffer.from(chunk));
+        }
+        bodyText = Buffer.concat(chunks).toString("utf-8");
+        if (textPart.isHtml)
+          bodyText = stripHtml(bodyText);
+      }
+      if (bodyText.length > MAX_BODY_CHARS) {
+        bodyText = bodyText.slice(0, MAX_BODY_CHARS) + "\n[truncated]";
+      }
+      const wasSeen = msg.flags?.has("\\Seen") ?? false;
+      await client.messageFlagsAdd(String(params.uid), ["\\Seen"], { uid: true });
+      const subject = msg.envelope?.subject ?? "(no subject)";
+      const from = extractAddress(msg.envelope?.from);
+      const date = msg.envelope?.date?.toISOString() ?? "unknown";
+      return `UID: ${params.uid}
+Subject: ${subject}
+From: ${from}
+Date: ${date}
+Status: ${wasSeen ? "was read" : "was unread, marked read"}
+
+${bodyText}`;
+    } finally {
+      lock.release();
+    }
+  });
+}
+async function handleSearch(params, imapConfig) {
+  const folder = params.folder ?? "INBOX";
+  const limit = params.limit ?? 10;
+  return withImapClient(imapConfig, async (client) => {
+    const lock = await client.getMailboxLock(folder);
+    try {
+      const criteria = {};
+      if (params.from)
+        criteria.from = params.from;
+      if (params.subject)
+        criteria.subject = params.subject;
+      if (params.since)
+        criteria.since = new Date(params.since);
+      if (params.unseen)
+        criteria.seen = false;
+      const result = await client.search(criteria, { uid: true });
+      const uids = Array.isArray(result) ? result : [];
+      if (uids.length === 0)
+        return "No emails match the search criteria.";
+      const selected = uids.slice(-limit);
+      const emails = [];
+      for await (const msg of client.fetch(selected, { envelope: true, flags: true }, { uid: true })) {
+        emails.push({
+          uid: msg.uid,
+          subject: msg.envelope?.subject ?? "(no subject)",
+          from: extractAddress(msg.envelope?.from),
+          date: msg.envelope?.date?.toISOString() ?? "unknown",
+          seen: msg.flags?.has("\\Seen") ?? false
+        });
+      }
+      return formatSummaries(emails);
+    } finally {
+      lock.release();
+    }
+  });
+}
+async function handleSend(params, smtpConfig) {
+  const transport = createTransport({
+    host: smtpConfig.host,
+    port: smtpConfig.port,
+    secure: smtpConfig.port === 465,
+    auth: { user: smtpConfig.user, pass: smtpConfig.password }
+  });
+  const info = await transport.sendMail({
+    from: smtpConfig.user,
+    to: params.to,
+    subject: params.subject,
+    text: params.body,
+    cc: params.cc,
+    bcc: params.bcc
+  });
+  return `Email sent. Message ID: ${info.messageId}`;
+}
+var emailTool = {
+  name: "email",
+  description: "Manage email: list recent messages, read by UID, search with criteria, or send an email via SMTP",
+  configCheck: (ctx) => ctx.config.tools?.email ? null : "This tool requires configuration. See https://augure.dev/docs/tools/email",
+  parameters: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["list", "read", "search", "send"],
+        description: "The email action to perform"
+      },
+      folder: {
+        type: "string",
+        description: 'IMAP folder (default: "INBOX"). Used by list, read, search.'
+      },
+      limit: {
+        type: "number",
+        description: "Max emails to return (default: 10). Used by list, search."
+      },
+      uid: { type: "number", description: "Email UID to read. Required for read." },
+      from: { type: "string", description: "Filter by sender address. Used by search." },
+      subject: {
+        type: "string",
+        description: "Filter by subject (search) or email subject (send)."
+      },
+      since: {
+        type: "string",
+        description: "ISO 8601 date \u2014 emails since this date. Used by search."
+      },
+      unseen: { type: "boolean", description: "Only unread emails. Used by search." },
+      to: { type: "string", description: "Recipient address. Required for send." },
+      body: { type: "string", description: "Email body text. Required for send." },
+      cc: { type: "string", description: "CC recipients. Used by send." },
+      bcc: { type: "string", description: "BCC recipients. Used by send." }
+    },
+    required: ["action"]
+  },
+  execute: async (params, ctx) => {
+    const p = params;
+    const emailConfig = ctx.config.tools?.email;
+    if (!emailConfig) {
+      return { success: false, output: "Email is not configured. Add tools.email to your config." };
+    }
+    try {
+      switch (p.action) {
+        case "list":
+          return { success: true, output: await handleList(p, emailConfig.imap) };
+        case "read":
+          if (!p.uid)
+            return { success: false, output: "Missing required field: uid" };
+          return { success: true, output: await handleRead(p, emailConfig.imap) };
+        case "search":
+          if (!p.from && !p.subject && !p.since && p.unseen === void 0)
+            return { success: false, output: "At least one search criterion is required (from, subject, since, or unseen)." };
+          return { success: true, output: await handleSearch(p, emailConfig.imap) };
+        case "send":
+          if (!p.to)
+            return { success: false, output: "Missing required field: to" };
+          if (!p.subject)
+            return { success: false, output: "Missing required field: subject" };
+          if (!p.body)
+            return { success: false, output: "Missing required field: body" };
+          return { success: true, output: await handleSend(p, emailConfig.smtp) };
+        default:
+          return { success: false, output: `Unknown action: ${p.action}` };
+      }
+    } catch (err2) {
+      return {
+        success: false,
+        output: err2 instanceof Error ? err2.message : String(err2)
+      };
+    }
+  }
+};
 
 // ../tools/dist/sandbox-exec.js
 var sandboxExecTool = {
@@ -1304,6 +2136,7 @@ function shellEscape(s) {
 var opencodeTool = {
   name: "opencode",
   description: "Run a code agent (claude-code, opencode, codex CLI) in a Docker container to perform a coding task.",
+  configCheck: (ctx) => ctx.config.sandbox.codeAgent ? null : "This tool requires sandbox.codeAgent configuration. See https://augure.dev/docs/sandbox",
   parameters: {
     type: "object",
     properties: {
@@ -1515,6 +2348,10 @@ var DockerContainer = class {
         }
       });
       this.demux(stream, stdoutPT, stderrPT);
+      stream.on("end", () => {
+        stdoutPT.end();
+        stderrPT.end();
+      });
     });
   }
 };
@@ -1540,6 +2377,7 @@ var DockerContainerPool = class {
   docker;
   image;
   maxTotal;
+  log;
   // C3: idle cache keyed by trust level to prevent cross-trust reuse
   idle = /* @__PURE__ */ new Map([
     ["sandboxed", /* @__PURE__ */ new Set()],
@@ -1551,6 +2389,7 @@ var DockerContainerPool = class {
     this.docker = docker;
     this.image = config.image;
     this.maxTotal = config.maxTotal;
+    this.log = config.logger ?? noopLogger;
   }
   get idleCount() {
     let count = 0;
@@ -1560,18 +2399,22 @@ var DockerContainerPool = class {
   }
   /* ---- acquire ---- */
   async acquire(opts) {
+    this.log.debug(`Acquiring container: trust=${opts.trust} memory=${opts.memory} cpu=${opts.cpu}`);
     const trustIdle = this.idle.get(opts.trust);
     const cached = trustIdle.values().next();
     if (!cached.done) {
       const container2 = cached.value;
       trustIdle.delete(container2);
       this.busy.add(container2);
+      this.log.debug(`Reusing cached container: ${container2.id.slice(0, 12)}`);
       return container2;
     }
     const total = this.idleCount + this.busy.size;
     if (total >= this.maxTotal) {
+      this.log.error(`Pool limit reached: ${total}/${this.maxTotal}`);
       throw new Error("Pool limit reached");
     }
+    this.log.debug("Creating new container...");
     const raw = await this.docker.createContainer(this.buildCreateOpts(opts));
     await raw.start();
     const modem = this.docker.modem;
@@ -1579,6 +2422,7 @@ var DockerContainerPool = class {
     const container = new DockerContainer(raw, demux);
     this.containerTrust.set(container.id, opts.trust);
     this.busy.add(container);
+    this.log.debug(`Container created: ${container.id.slice(0, 12)}`);
     return container;
   }
   /* ---- release ---- */
@@ -1590,6 +2434,7 @@ var DockerContainerPool = class {
     }
     const trust = this.containerTrust.get(container.id) ?? "sandboxed";
     this.idle.get(trust).add(container);
+    this.log.debug(`Container released: ${container.id.slice(0, 12)} \u2192 idle (${trust})`);
   }
   /* ---- destroy ---- */
   async destroy(container) {
@@ -1678,16 +2523,19 @@ function buildTar(content) {
   const end = Buffer.alloc(1024, 0);
   return Buffer.concat([header, dataPadded, end]);
 }
-async function ensureImage(docker, imageName) {
+async function ensureImage(docker, imageName, logger) {
+  const log = logger ?? noopLogger;
+  log.debug(`Checking image: ${imageName}`);
   try {
     await docker.getImage(imageName).inspect();
+    log.debug("Image exists");
     return;
   } catch (err2) {
     const statusCode = err2.statusCode;
     if (statusCode !== void 0 && statusCode !== 404)
       throw err2;
   }
-  console.log(`[augure] Image "${imageName}" not found, building...`);
+  log.info(`Image "${imageName}" not found, building...`);
   const tar = buildTar(DOCKERFILE);
   const stream = await docker.buildImage(Readable.from(tar), {
     t: imageName
@@ -1699,11 +2547,14 @@ async function ensureImage(docker, imageName) {
       else
         resolve5();
     }, (event) => {
-      if (event.stream)
-        process.stdout.write(event.stream);
+      if (event.stream) {
+        const line = event.stream.trim();
+        if (line)
+          log.debug(line);
+      }
     });
   });
-  console.log(`[augure] Image "${imageName}" built successfully`);
+  log.info(`Image "${imageName}" built`);
 }
 
 // ../memory/dist/store.js
@@ -1872,6 +2723,7 @@ var CronScheduler = class {
   timers = /* @__PURE__ */ new Map();
   handlers = [];
   persistChain = Promise.resolve();
+  running = false;
   constructor(store) {
     this.store = store;
   }
@@ -1889,12 +2741,21 @@ var CronScheduler = class {
       throw new Error(`Invalid runAt date: ${job.runAt}`);
     }
     this.jobs.set(job.id, job);
+    console.log(`[scheduler] Added job ${job.id} (${job.cron ? `cron: ${job.cron}` : `runAt: ${job.runAt}`})`);
     if (job.enabled && job.cron) {
       const task = createTask(job.cron, () => {
+        console.log(`[scheduler] Cron fired for job ${job.id}`);
         void this.executeHandlers(job);
       });
+      if (this.running) {
+        task.start();
+        console.log(`[scheduler] Started cron task for ${job.id} immediately (scheduler already running)`);
+      }
       this.tasks.set(job.id, task);
     }
+    if (this.running && job.enabled && job.runAt && !job.cron) {
+      this.scheduleOneShot(job);
+    }
     this.persist();
   }
   removeJob(id) {
@@ -1909,6 +2770,7 @@ var CronScheduler = class {
       this.timers.delete(id);
     }
     this.jobs.delete(id);
+    console.log(`[scheduler] Removed job ${id}`);
     this.persist();
   }
   listJobs() {
@@ -1925,16 +2787,21 @@ var CronScheduler = class {
     if (!this.store)
       return;
     const jobs = await this.store.load();
+    console.log(`[scheduler] Loading ${jobs.length} persisted jobs`);
     for (const job of jobs) {
       if (job.runAt && Date.parse(job.runAt) <= Date.now()) {
+        console.log(`[scheduler] Skipping expired one-shot job ${job.id} (runAt: ${job.runAt})`);
         continue;
       }
       this.addJob(job);
     }
   }
   start() {
-    for (const task of this.tasks.values()) {
+    this.running = true;
+    console.log(`[scheduler] Starting with ${this.tasks.size} cron tasks and ${this.handlers.length} handlers`);
+    for (const [id, task] of this.tasks) {
       task.start();
+      console.log(`[scheduler] Started cron task: ${id}`);
     }
     for (const job of this.jobs.values()) {
       if (job.enabled && job.runAt && !job.cron) {
@@ -1943,6 +2810,7 @@ var CronScheduler = class {
     }
   }
   stop() {
+    this.running = false;
     for (const task of this.tasks.values()) {
       task.stop();
     }
@@ -1953,9 +2821,13 @@ var CronScheduler = class {
   }
   scheduleOneShot(job) {
     const delayMs = Date.parse(job.runAt) - Date.now();
-    if (delayMs <= 0)
+    if (delayMs <= 0) {
+      console.log(`[scheduler] One-shot job ${job.id} already expired (delay: ${delayMs}ms), skipping`);
       return;
+    }
+    console.log(`[scheduler] Scheduled one-shot job ${job.id} in ${Math.round(delayMs / 1e3)}s (${job.runAt})`);
     const timer = setTimeout(() => {
+      console.log(`[scheduler] One-shot job ${job.id} firing now`);
       this.timers.delete(job.id);
       void this.executeHandlers(job).then(() => {
         this.removeJob(job.id);
@@ -1970,6 +2842,7 @@ var CronScheduler = class {
     this.persistChain = this.persistChain.then(() => this.store.save(jobs));
   }
   async executeHandlers(job) {
+    console.log(`[scheduler] Executing ${this.handlers.length} handlers for job ${job.id}`);
     for (const handler of this.handlers) {
       await handler(job);
     }
@@ -2016,10 +2889,13 @@ Be concise. Only suggest actions that are clearly needed based on the memory con
 var Heartbeat = class {
   config;
   timer;
+  log;
   constructor(config) {
     this.config = config;
+    this.log = config.logger ?? noopLogger;
   }
   async tick() {
+    this.log.debug("Heartbeat tick");
     const memoryContent = await this.loadMemory();
     const messages = [
       { role: "system", content: HEARTBEAT_PROMPT },
@@ -2034,12 +2910,15 @@ ${memoryContent}`
     const response = await this.config.llm.chat(messages);
     const action = this.parseAction(response.content);
     if (action && action.toLowerCase() !== "none") {
+      this.log.debug(`Heartbeat action: ${action}`);
       await this.config.onAction(action);
+    } else {
+      this.log.debug("Heartbeat: no action needed");
     }
   }
   start() {
     this.timer = setInterval(() => {
-      this.tick().catch((err2) => console.error("[augure] Heartbeat error:", err2));
+      this.tick().catch((err2) => this.log.error("Heartbeat error:", err2));
     }, this.config.intervalMs);
   }
   stop() {
@@ -2886,9 +3765,11 @@ var JOB_PREFIX = "skill:";
 var SkillSchedulerBridge = class {
   scheduler;
   manager;
-  constructor(scheduler, manager) {
+  log;
+  constructor(scheduler, manager, logger) {
     this.scheduler = scheduler;
     this.manager = manager;
+    this.log = logger ?? noopLogger;
   }
   /** Register cron jobs for all active cron-triggered skills */
   async syncAll() {
@@ -2907,7 +3788,7 @@ var SkillSchedulerBridge = class {
               enabled: true
             });
           } catch (err2) {
-            console.error(`[skills] Failed to register cron for ${skill.id}:`, err2);
+            this.log.error(`Failed to register cron for ${skill.id}:`, err2);
           }
         }
         existingJobs.delete(jobId);
@@ -3401,27 +4282,48 @@ var VersionChecker = class _VersionChecker {
 };
 
 // ../core/dist/main.js
-var SYSTEM_PROMPT = `You are Augure, a personal AI assistant. You are proactive, helpful, and concise.
+var BASE_SYSTEM_PROMPT = `You are Augure, a personal AI assistant. You are proactive, helpful, and concise.
 You speak the same language as the user. You have access to tools and persistent memory.
-Always be direct and actionable.`;
-function resolveLLMClient(config, usage) {
+Always be direct and actionable.
+
+## Your capabilities
+
+You have access to tools that let you interact with the outside world. Use the datetime tool when the user needs precise time information beyond what is shown in the current date above. Use memory tools to remember and recall information across conversations. Use the schedule tool to create recurring or one-shot tasks.
+
+If a tool is marked as [NOT CONFIGURED], let the user know it needs to be set up first and share the documentation link from the tool description.`;
+var SKILLS_PROMPT = `
+## Skills
+
+You can create and manage "skills" \u2014 autonomous code units that run in isolated Docker containers. Skills are powerful: they let you automate tasks, run on a schedule, and self-heal when they break.
+
+- Use skill_list to see existing skills and their status
+- Use skill_generate to create a new skill from a natural language description
+- Use skill_run to execute a skill manually
+- Use skill_heal to fix a broken skill
+- Use skill_install to install a skill from the hub
+
+When a user asks to automate a recurring task (e.g. "check this every morning", "send me a summary daily"), suggest creating a skill with a cron trigger. Skills can also be triggered manually or by events.`;
+function resolveLLMClient(config, usage, logger) {
   const override = usage !== "default" ? config[usage] : void 0;
   return new OpenRouterClient({
     apiKey: override?.apiKey ?? config.default.apiKey,
     model: override?.model ?? config.default.model,
-    maxTokens: override?.maxTokens ?? config.default.maxTokens
+    maxTokens: override?.maxTokens ?? config.default.maxTokens,
+    logger: logger.child("llm")
   });
 }
-async function startAgent(configPath) {
+async function startAgent(configPath, opts) {
+  const log = createLogger({ level: opts?.debug ? "debug" : "info" });
   const config = await loadConfig(configPath);
-  console.log(`[augure] Loaded config: ${config.identity.name}`);
+  log.info(`Loaded config: ${config.identity.name}`);
+  log.debug(`Config path: ${configPath}`);
   let telegram;
-  const llm = resolveLLMClient(config.llm, "default");
-  const ingestionLLM = resolveLLMClient(config.llm, "ingestion");
-  const monitoringLLM = resolveLLMClient(config.llm, "monitoring");
+  const llm = resolveLLMClient(config.llm, "default", log);
+  const ingestionLLM = resolveLLMClient(config.llm, "ingestion", log);
+  const monitoringLLM = resolveLLMClient(config.llm, "monitoring", log);
   const memoryPath = resolve(configPath, "..", config.memory.path);
   const memory = new FileMemoryStore(memoryPath);
-  console.log(`[augure] Memory store: ${memoryPath}`);
+  log.info(`Memory store: ${memoryPath}`);
   const retriever = new MemoryRetriever(memory, {
     maxTokens: config.memory.maxRetrievalTokens
   });
@@ -3430,15 +4332,17 @@ async function startAgent(configPath) {
   tools.register(memoryReadTool);
   tools.register(memoryWriteTool);
   tools.register(scheduleTool);
+  tools.register(datetimeTool);
   tools.register(webSearchTool);
   tools.register(httpTool);
+  tools.register(emailTool);
   tools.register(sandboxExecTool);
   tools.register(opencodeTool);
   const jobStorePath = resolve(configPath, "..", "jobs.json");
   const jobStore = new JobStore(jobStorePath);
   const scheduler = new CronScheduler(jobStore);
   await scheduler.loadPersistedJobs();
-  console.log(`[augure] Loaded ${scheduler.listJobs().length} persisted jobs`);
+  log.info(`Loaded ${scheduler.listJobs().length} persisted jobs`);
   for (const job of config.scheduler.jobs) {
     if (!scheduler.listJobs().some((j) => j.id === job.id)) {
       scheduler.addJob({ ...job, enabled: true });
@@ -3446,17 +4350,19 @@ async function startAgent(configPath) {
   }
   const docker = new Dockerode();
   const sandboxImage = config.sandbox.image ?? "augure-sandbox:latest";
-  await ensureImage(docker, sandboxImage);
+  const sandboxLog = log.child("sandbox");
+  await ensureImage(docker, sandboxImage, sandboxLog);
   const pool = new DockerContainerPool(docker, {
     image: sandboxImage,
-    maxTotal: config.security.maxConcurrentSandboxes
+    maxTotal: config.security.maxConcurrentSandboxes,
+    logger: sandboxLog
   });
-  console.log(`[augure] Container pool created (max: ${config.security.maxConcurrentSandboxes})`);
+  log.info(`Container pool: max=${config.security.maxConcurrentSandboxes}`);
   let skillManagerRef;
   let skillUpdater;
   if (config.skills) {
     const skillsPath = resolve(configPath, "..", config.skills.path);
-    const codingLLM = resolveLLMClient(config.llm, "coding");
+    const codingLLM = resolveLLMClient(config.llm, "coding", log);
     const skillManager = new SkillManager(skillsPath);
     const skillGenerator = new SkillGenerator(codingLLM);
     const skillRunner = new SkillRunner({
@@ -3500,29 +4406,63 @@ async function startAgent(configPath) {
         const updated = updateResults.filter((r) => r.success);
         const failed = updateResults.filter((r) => !r.success);
         if (updated.length > 0) {
-          console.log(`[augure] Skills updated: ${updated.map((r) => `${r.skillId} (v${r.fromVersion}\u2192v${r.toVersion})`).join(", ")}`);
+          log.info(`Skills updated: ${updated.map((r) => `${r.skillId} (v${r.fromVersion}\u2192v${r.toVersion})`).join(", ")}`);
         }
         if (failed.length > 0) {
-          console.log(`[augure] Skill updates failed: ${failed.map((r) => `${r.skillId}: ${r.error}`).join(", ")}`);
+          log.warn(`Skill updates failed: ${failed.map((r) => `${r.skillId}: ${r.error}`).join(", ")}`);
         }
       } catch (err2) {
-        console.error("[augure] Skill update check failed:", err2);
+        log.error("Skill update check failed:", err2);
       }
     }
     skillManagerRef = skillManager;
-    console.log(`[augure] Skills system initialized at ${skillsPath}`);
+    log.info(`Skills initialized: ${skillsPath}`);
   }
   tools.setContext({ config, memory, scheduler, pool });
+  let codeModeExecutor;
+  if (config.codeMode) {
+    const cmConfig = config.codeMode;
+    if (cmConfig.runtime === "vm") {
+      codeModeExecutor = new VmExecutor(tools, {
+        timeout: cmConfig.timeout * 1e3,
+        // VmExecutor expects ms
+        memoryLimit: cmConfig.memoryLimit
+      });
+    } else if (cmConfig.runtime === "docker") {
+      codeModeExecutor = new DockerExecutor({
+        registry: tools,
+        pool,
+        timeout: cmConfig.timeout,
+        // DockerExecutor expects seconds
+        memoryLimit: config.sandbox.defaults.memoryLimit,
+        cpuLimit: config.sandbox.defaults.cpuLimit
+      });
+    } else {
+      const vmExec = new VmExecutor(tools, {
+        timeout: cmConfig.timeout * 1e3,
+        memoryLimit: cmConfig.memoryLimit
+      });
+      const dockerExec = new DockerExecutor({
+        registry: tools,
+        pool,
+        timeout: cmConfig.timeout,
+        memoryLimit: config.sandbox.defaults.memoryLimit,
+        cpuLimit: config.sandbox.defaults.cpuLimit
+      });
+      codeModeExecutor = new AutoExecutor(vmExec, dockerExec);
+    }
+    log.info(`Code Mode enabled: runtime=${cmConfig.runtime}, timeout=${cmConfig.timeout}s`);
+  }
   const auditConfig = config.audit ?? { path: "./logs", enabled: true };
   const auditPath = resolve(configPath, "..", auditConfig.path);
-  const audit = auditConfig.enabled ? new FileAuditLogger(auditPath) : new NullAuditLogger();
-  console.log(`[augure] Audit logger: ${auditConfig.enabled ? auditPath : "disabled"}`);
+  const audit = auditConfig.enabled ? new FileAuditLogger(auditPath, log.child("audit")) : new NullAuditLogger();
+  log.info(`Audit: ${auditConfig.enabled ? auditPath : "disabled"}`);
   let personaResolver;
   if (config.persona) {
     const personaPath = resolve(configPath, "..", config.persona.path);
     personaResolver = new PersonaResolver(personaPath);
     await personaResolver.loadAll();
-    console.log(`[augure] Personas loaded from ${personaPath}`);
+    log.info(`Personas: ${personaPath}`);
   }
   let cliVersion;
   try {
@@ -3538,29 +4478,34 @@ async function startAgent(configPath) {
     });
     const versionResult = await versionChecker.check();
     if (versionResult.updateAvailable) {
-      console.log(`[augure] Update available: v${versionResult.latestVersion} (current: v${versionResult.currentVersion}). Run: npm update -g augure`);
+      log.warn(`Update available: v${versionResult.latestVersion} (current: v${versionResult.currentVersion}). Run: npm update -g augure`);
     }
   }
   const guard = new ContextGuard({
     maxContextTokens: 2e5,
     reservedForOutput: config.llm.default.maxTokens ?? 8192
   });
+  const systemPrompt = config.skills ? BASE_SYSTEM_PROMPT + SKILLS_PROMPT : BASE_SYSTEM_PROMPT;
   const agent = new Agent({
     llm,
     tools,
-    systemPrompt: SYSTEM_PROMPT,
+    systemPrompt,
     memoryContent: "",
     retriever,
     ingester,
     audit,
     guard,
-    modelName: config.llm.default.model
+    modelName: config.llm.default.model,
+    logger: log.child("agent"),
+    codeModeExecutor
   });
   if (config.channels.telegram?.enabled) {
+    const telegramLog = log.child("telegram");
     telegram = new TelegramChannel({
       botToken: config.channels.telegram.botToken,
       allowedUsers: config.channels.telegram.allowedUsers,
-      rejectMessage: config.channels.telegram.rejectMessage
+      rejectMessage: config.channels.telegram.rejectMessage,
+      logger: telegramLog
     });
     const tg = telegram;
     const commandCtx = {
@@ -3570,7 +4515,7 @@ async function startAgent(configPath) {
       skillManager: skillManagerRef
     };
     tg.onMessage(async (msg) => {
-      console.log(`[augure] Message from ${msg.userId}: ${msg.text}`);
+      log.info(`Message from ${msg.userId}: ${msg.text}`);
       try {
         const cmdResult = await handleCommand(msg.text, commandCtx);
         if (cmdResult.handled) {
@@ -3593,7 +4538,7 @@ async function startAgent(configPath) {
           replyTo: msg.id
         });
       } catch (err2) {
-        console.error("[augure] Error handling message:", err2);
+        log.error("Error handling message:", err2);
         await tg.send({
           channelType: "telegram",
           userId: msg.userId,
@@ -3602,15 +4547,16 @@ async function startAgent(configPath) {
       }
     });
     await tg.start();
-    console.log("[augure] Telegram bot started. Waiting for messages...");
+    log.info("Telegram bot started");
   }
   const heartbeatIntervalMs = parseInterval(config.scheduler.heartbeatInterval);
   const heartbeat = new Heartbeat({
     llm: monitoringLLM,
     memory,
     intervalMs: heartbeatIntervalMs,
+    logger: log.child("heartbeat"),
     onAction: async (action) => {
-      console.log(`[augure] Heartbeat action: ${action}`);
+      log.info(`Heartbeat action: ${action}`);
       const response = await agent.handleMessage({
         id: `heartbeat-${Date.now()}`,
         channelType: "system",
@@ -3618,11 +4564,11 @@ async function startAgent(configPath) {
         text: `[Heartbeat] ${action}`,
         timestamp: /* @__PURE__ */ new Date()
       });
-      console.log(`[augure] Heartbeat response: ${response}`);
+      log.debug(`Heartbeat response: ${response.slice(0, 200)}`);
     }
   });
   scheduler.onJobTrigger(async (job) => {
-    console.log(`[augure] Job triggered: ${job.id}`);
+    log.info(`Job triggered: ${job.id}`);
     const response = await agent.handleMessage({
       id: `job-${job.id}-${Date.now()}`,
       channelType: "system",
@@ -3640,11 +4586,11 @@ async function startAgent(configPath) {
         });
       }
     }
-    console.log(`[augure] Job ${job.id} completed`);
+    log.debug(`Job ${job.id} completed`);
   });
   scheduler.start();
   heartbeat.start();
-  console.log(`[augure] Scheduler started with ${scheduler.listJobs().length} jobs. Heartbeat every ${config.scheduler.heartbeatInterval}.`);
+  log.info(`Scheduler started: ${scheduler.listJobs().length} jobs, heartbeat every ${config.scheduler.heartbeatInterval}`);
   const updateTimers = [];
   if (skillUpdater && config.updates?.skills?.checkInterval) {
     const su = skillUpdater;
@@ -3654,13 +4600,13 @@ async function startAgent(configPath) {
         const results = await su.checkAndApply();
         for (const r of results) {
           if (r.success) {
-            console.log(`[augure] Skill auto-updated: ${r.skillId} v${r.fromVersion}\u2192v${r.toVersion}`);
+            log.info(`Skill auto-updated: ${r.skillId} v${r.fromVersion}\u2192v${r.toVersion}`);
           } else if (r.rolledBack) {
-            console.log(`[augure] Skill update rolled back: ${r.skillId} - ${r.error}`);
+            log.warn(`Skill update rolled back: ${r.skillId} - ${r.error}`);
           }
         }
       } catch (err2) {
-        console.error("[augure] Periodic skill update check failed:", err2);
+        log.error("Periodic skill update check failed:", err2);
       }
     }, skillCheckMs));
   }
@@ -3685,12 +4631,12 @@ Run: \`npm update -g augure\``
           }
         }
       } catch (err2) {
-        console.error("[augure] CLI version check failed:", err2);
+        log.error("CLI version check failed:", err2);
       }
     }, cliCheckMs));
   }
   const shutdown = async () => {
-    console.log("\n[augure] Shutting down...");
+    log.info("Shutting down...");
     for (const timer of updateTimers)
       clearInterval(timer);
     heartbeat.stop();
@@ -3699,23 +4645,13 @@ Run: \`npm update -g augure\``
       await telegram.stop();
     await pool.destroyAll();
     await audit.close();
-    console.log("[augure] All containers destroyed");
+    log.info("All containers destroyed");
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
 
-// src/colors.ts
-import { styleText } from "util";
-var brand = (s) => styleText("yellow", s);
-var ok = (s) => styleText("green", s);
-var err = (s) => styleText("red", s);
-var dim = (s) => styleText("dim", s);
-var bold = (s) => styleText("bold", s);
-var cyan = (s) => styleText("cyan", s);
-var prefix = brand("\u25B2 augure");
-
 // src/commands/start.ts
 var startCommand = defineCommand({
   meta: {
@@ -3733,21 +4669,28 @@ var startCommand = defineCommand({
       type: "string",
       description: "Path to .env file",
       alias: "e"
+    },
+    debug: {
+      type: "boolean",
+      description: "Enable debug logging",
+      alias: "d",
+      default: false
     }
   },
   async run({ args }) {
     const configPath = resolve2(args.config);
+    const log = createLogger({ level: args.debug ? "debug" : "info" });
     const envPath = args.env ? resolve2(args.env) : join6(dirname4(configPath), ".env");
     try {
       process.loadEnvFile(envPath);
-      console.log(`${prefix} Loaded env from ${dim(envPath)}`);
+      log.debug(`Loaded env from ${envPath}`);
     } catch {
     }
-    console.log(`${prefix} Starting with config: ${dim(configPath)}`);
+    log.info(`Starting with config: ${configPath}`);
     try {
-      await startAgent(configPath);
+      await startAgent(configPath, { debug: args.debug });
     } catch (e) {
-      console.error(`${prefix} ${err("Fatal error:")} ${e instanceof Error ? e.message : e}`);
+      log.error("Fatal:", e instanceof Error ? e.message : String(e));
       process.exit(1);
     }
   }
@@ -3757,6 +4700,18 @@ var startCommand = defineCommand({
 import { defineCommand as defineCommand2 } from "citty";
 import { writeFile as writeFile5, access as access3 } from "fs/promises";
 import { resolve as resolve3 } from "path";
+
+// src/colors.ts
+import { styleText as styleText2 } from "util";
+var brand = (s) => styleText2("yellow", s);
+var ok = (s) => styleText2("green", s);
+var err = (s) => styleText2("red", s);
+var dim = (s) => styleText2("dim", s);
+var bold = (s) => styleText2("bold", s);
+var cyan = (s) => styleText2("cyan", s);
+var prefix = brand("\u25B2 augure");
+
+// src/commands/init.ts
 var CONFIG_TEMPLATE = `{
   // Identity
   identity: {