augure 0.8.0 → 0.9.0

package/dist/chunk-KC5S36DB.js

@@ -0,0 +1,2074 @@
+#!/usr/bin/env node
+import {
+  ToolRegistry,
+  createBrowserTool,
+  datetimeTool,
+  emailTool,
+  githubTool,
+  httpTool,
+  memoryReadTool,
+  memoryWriteTool,
+  opencodeTool,
+  sandboxExecTool,
+  scheduleTool,
+  webSearchTool
+} from "./chunk-63TMJ6FS.js";
+import {
+  BrowserSessionManager
+} from "./chunk-H6PBSIJ5.js";
+import {
+  DockerContainerPool,
+  ensureImage
+} from "./chunk-TP6A6GFU.js";
+import {
+  FileMemoryStore,
+  MemoryIngester,
+  MemoryRetriever
+} from "./chunk-M63XRSRV.js";
+import {
+  CronScheduler,
+  Heartbeat,
+  JobStore,
+  parseInterval
+} from "./chunk-3BGYMW62.js";
+import {
+  SkillGenerator,
+  SkillHealer,
+  SkillHub,
+  SkillManager,
+  SkillRunner,
+  SkillSchedulerBridge,
+  SkillTester,
+  SkillUpdater,
+  createSkillTools,
+  installBuiltins
+} from "./chunk-XOMIXLMX.js";
+import {
+  noopLogger
+} from "./chunk-62OPINAX.js";
+
+// ../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()),
+      rejectMessage: z.string().optional()
+    }).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).optional(),
+      runAt: z.string().min(1).optional(),
+      prompt: z.string().min(1),
+      channel: z.string().min(1)
+    }).refine((j) => j.cron || j.runAt, {
+      message: "Job must have either cron or runAt"
+    }))
+  }),
+  sandbox: z.object({
+    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(),
+    browser: z.object({
+      provider: z.enum(["local", "browserbase"]),
+      browserbase: z.object({
+        apiKey: z.string().min(1),
+        projectId: z.string().optional()
+      }).optional(),
+      defaults: z.object({
+        timeout: z.number().int().positive().optional(),
+        headless: z.boolean().optional(),
+        viewport: z.object({
+          width: z.number().int().positive(),
+          height: z.number().int().positive()
+        }).optional()
+      }).optional()
+    }).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(),
+  updates: z.object({
+    skills: z.object({
+      enabled: z.boolean().default(true),
+      checkInterval: z.string().min(1).default("6h")
+    }).optional(),
+    cli: z.object({
+      enabled: z.boolean().default(true),
+      checkInterval: z.string().min(1).default("24h"),
+      notifyChannel: z.string().min(1).default("telegram")
+    }).optional()
+  }).optional(),
+  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(),
+  approval: z.object({
+    enabled: z.boolean(),
+    timeoutMs: z.number().int().positive().default(12e4)
+  }).optional(),
+  mcp: z.object({
+    enabled: z.boolean(),
+    port: z.number().int().positive().default(3100)
+  }).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;
+  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 fetchStart = Date.now();
+    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 } : {},
+          ...m.toolCalls?.length ? {
+            tool_calls: m.toolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function",
+              function: {
+                name: tc.name,
+                arguments: JSON.stringify(tc.arguments)
+              }
+            }))
+          } : {}
+        })),
+        ...tools?.length ? { tools } : {}
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`OpenRouter API error ${response.status}: ${body}`);
+    }
+    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 in ${Date.now() - fetchStart}ms`);
+    return {
+      content: choice.message.content ?? "",
+      toolCalls: (choice.message.tool_calls ?? []).map((tc) => {
+        let args = {};
+        try {
+          args = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+        } catch {
+          this.log.warn(`Failed to parse tool call arguments for ${tc.function.name}`);
+        }
+        return { id: tc.id, name: tc.function.name, arguments: args };
+      }),
+      usage: {
+        inputTokens: data.usage.prompt_tokens,
+        outputTokens: data.usage.completion_tokens
+      }
+    };
+  }
+};
+
+// ../core/dist/context.js
+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 += `
+
+## Active Persona
+${persona}`;
+  }
+  if (memoryContent) {
+    system += `
+
+## Memory
+${memoryContent}`;
+  }
+  const messages = [{ role: "system", content: system }];
+  messages.push(...conversationHistory);
+  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 (err) {
+      return {
+        success: false,
+        output: `Bridge error calling ${toolName}: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  };
+}
+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 (err) {
+      const durationMs = performance.now() - start;
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        error: err instanceof Error ? err.message : String(err),
+        durationMs,
+        toolCalls: 0
+      };
+    }
+  }
+};
+
+// ../code-mode/dist/docker-sandbox.js
+var DOCKER_HARNESS = `
+import { readFile, writeFile, unlink } 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;
+let __reqId = 0;
+
+const __BRIDGE_TIMEOUT = 120_000;
+const api = new Proxy({}, {
+  get: (_target, toolName) => {
+    return async (args) => {
+      __toolCalls++;
+      const id = String(++__reqId);
+      const reqPath = \`/workspace/.bridge-req-\${id}.json\`;
+      const respPath = \`/workspace/.bridge-resp-\${id}.json\`;
+      await writeFile(reqPath, JSON.stringify({ id, tool: String(toolName), args }));
+      const deadline = Date.now() + __BRIDGE_TIMEOUT;
+      while (Date.now() < deadline) {
+        try {
+          const data = await readFile(respPath, "utf-8");
+          await unlink(respPath);
+          return JSON.parse(data);
+        } catch {
+          await new Promise(r => setTimeout(r, 50));
+        }
+      }
+      throw new Error(\`Bridge timeout: tool "\${String(toolName)}" did not respond within \${__BRIDGE_TIMEOUT}ms\`);
+    };
+  }
+});
+
+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,
+  }));
+}
+`;
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function parseFiles(stdout) {
+  return stdout.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("/workspace/.bridge-req-") && l.endsWith(".json"));
+}
+var DockerExecutor = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async pollBridge(container, abortSignal) {
+    while (!abortSignal.aborted) {
+      try {
+        const ls = await container.exec("ls /workspace/.bridge-req-*.json 2>/dev/null || true");
+        const files = parseFiles(ls.stdout);
+        for (const reqFile of files) {
+          const reqJson = await container.exec(`cat ${reqFile}`);
+          const req = JSON.parse(reqJson.stdout);
+          const result = await this.config.registry.execute(req.tool, req.args);
+          const respFile = reqFile.replace("bridge-req", "bridge-resp");
+          const respB64 = Buffer.from(JSON.stringify(result)).toString("base64");
+          const tmpFile = `${respFile}.tmp`;
+          await container.exec(`sh -c 'echo "${respB64}" | base64 -d > ${tmpFile} && mv ${tmpFile} ${respFile}'`);
+          await container.exec(`rm ${reqFile}`);
+        }
+      } catch {
+      }
+      await sleep(100);
+    }
+  }
+  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 (err) {
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        toolCalls: 0,
+        error: `Failed to acquire container: ${err instanceof Error ? err.message : String(err)}`,
+        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 abortController = new AbortController();
+      const bridgePromise = this.pollBridge(container, abortController.signal);
+      const execResult = await container.exec("npx tsx /workspace/harness.ts", {
+        timeout: this.config.timeout,
+        cwd: "/workspace"
+      });
+      abortController.abort();
+      await bridgePromise;
+      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 (err) {
+      return {
+        success: false,
+        output: void 0,
+        logs: [],
+        toolCalls: 0,
+        error: err instanceof Error ? err.message : String(err),
+        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";
+function summarize(text, maxLen = 200) {
+  if (text.length <= maxLen)
+    return text;
+  return text.slice(0, maxLen) + "...";
+}
+var FileAuditLogger = class {
+  basePath;
+  logger;
+  pendingWrite = Promise.resolve();
+  initialized = false;
+  constructor(basePath, logger) {
+    this.basePath = basePath;
+    this.logger = logger ?? noopLogger;
+  }
+  log(entry) {
+    this.pendingWrite = this.pendingWrite.then(() => this.writeEntry(entry)).catch((err) => this.logger.error("Audit write error:", err));
+  }
+  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;
+  log;
+  conversations = /* @__PURE__ */ new Map();
+  state = "running";
+  constructor(config) {
+    this.config = config;
+    this.log = config.logger ?? noopLogger;
+  }
+  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();
+    const userId = incoming.userId;
+    let history = this.conversations.get(userId) ?? [];
+    history.push({
+      role: "user",
+      content: incoming.text
+    });
+    if (this.config.guard) {
+      history = this.config.guard.compact(history);
+    }
+    this.conversations.set(userId, history);
+    let memoryContent = this.config.memoryContent;
+    if (this.config.retriever) {
+      memoryContent = await this.config.retriever.retrieve();
+    }
+    const maxLoops = this.config.maxToolLoops ?? 10;
+    let loopCount = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalToolCalls = 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,
+        memoryContent,
+        conversationHistory: history,
+        persona: this.config.persona
+      });
+      this.log.debug(`LLM call #${loopCount + 1} (${messages.length} messages)`);
+      const response = await this.config.llm.chat(messages, effectiveSchemas);
+      totalInputTokens += response.usage.inputTokens;
+      totalOutputTokens += response.usage.outputTokens;
+      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(),
+            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
+          });
+        }
+        this.log.info(`\u2500\u2500 ${totalInputTokens}+${totalOutputTokens} tokens | ${loopCount + 1} LLM calls | ${totalToolCalls} tool calls | ${Date.now() - start}ms`);
+        if (this.config.ingester) {
+          this.config.ingester.ingest(history).catch((err) => this.log.error("Ingestion error:", err));
+        }
+        return response.content;
+      }
+      history.push({
+        role: "assistant",
+        content: response.content || "",
+        toolCalls: response.toolCalls
+      });
+      totalToolCalls += response.toolCalls.length;
+      for (const toolCall of response.toolCalls) {
+        const toolStart = Date.now();
+        this.log.debug(`Tool: ${toolCall.name}`);
+        const registeredTool = this.config.tools.get(toolCall.name);
+        if (registeredTool?.riskLevel === "high" && this.config.approvalGate) {
+          const approved = await this.config.approvalGate.request(incoming.userId, toolCall.name, toolCall.arguments);
+          if (!approved) {
+            history.push({
+              role: "tool",
+              content: "Tool call rejected by user.",
+              toolCallId: toolCall.id
+            });
+            continue;
+          }
+        }
+        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,
+          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(userId) {
+    if (userId) {
+      return [...this.conversations.get(userId) ?? []];
+    }
+    const all = [];
+    for (const msgs of this.conversations.values()) {
+      all.push(...msgs);
+    }
+    return all;
+  }
+  clearHistory(userId) {
+    if (userId) {
+      this.conversations.delete(userId);
+    } else {
+      this.conversations.clear();
+    }
+  }
+};
+
+// ../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));
+  }
+  listAll() {
+    return [...this.personas];
+  }
+  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;
+  }
+};
+
+// ../core/dist/approval.js
+import { randomUUID } from "crypto";
+var ApprovalGate = class {
+  pending = /* @__PURE__ */ new Map();
+  channel;
+  timeoutMs;
+  log;
+  constructor(config) {
+    this.channel = config.channel;
+    this.timeoutMs = config.timeoutMs ?? 12e4;
+    this.log = config.logger ?? noopLogger;
+    if (this.channel.onApprovalResponse) {
+      this.channel.onApprovalResponse((response) => {
+        const entry = this.pending.get(response.requestId);
+        if (entry) {
+          this.pending.delete(response.requestId);
+          entry.resolve(response.approved);
+        }
+      });
+    }
+  }
+  async request(userId, toolName, args) {
+    if (!this.channel.sendApprovalRequest) {
+      this.log.warn(`Channel does not support approval requests \u2014 auto-approving ${toolName}`);
+      return true;
+    }
+    const requestId = randomUUID();
+    const argsStr = JSON.stringify(args, null, 2);
+    const text = `Tool "${toolName}" requires approval.
+
+Arguments:
+${argsStr}`;
+    const buttons = [
+      { label: "Approve", callbackData: `approve:${requestId}` },
+      { label: "Reject", callbackData: `reject:${requestId}` }
+    ];
+    const resultPromise = new Promise((resolve2) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        this.log.warn(`Approval timed out for ${toolName} (request ${requestId})`);
+        resolve2(false);
+      }, this.timeoutMs);
+      this.pending.set(requestId, {
+        resolve: (approved) => {
+          clearTimeout(timer);
+          resolve2(approved);
+        }
+      });
+    });
+    await this.channel.sendApprovalRequest(userId, text, buttons, requestId);
+    return resultPromise;
+  }
+};
+
+// ../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 prefix = `${styleText("yellow", "\u25B2")} ${ts} ${lvl}${sc}`;
+    const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+    if (args.length > 0) {
+      fn(prefix, msg, ...args);
+    } else {
+      fn(prefix, 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, InlineKeyboard } from "grammy";
+
+// ../channels/dist/pipeline.js
+function createOutgoingPipeline(middlewares, send) {
+  return async (message) => {
+    let index = 0;
+    const next = async () => {
+      if (index < middlewares.length) {
+        const mw = middlewares[index++];
+        await mw(message, next);
+      } else {
+        await send(message);
+      }
+    };
+    await next();
+  };
+}
+
+// ../channels/dist/middleware/split-message.js
+var TELEGRAM_MAX = 4096;
+function splitText(text, maxLength) {
+  if (text.length <= maxLength)
+    return [text];
+  const chunks = [];
+  let remaining = text;
+  let openCodeBlock = null;
+  while (remaining.length > 0) {
+    const prefix = openCodeBlock ? `${openCodeBlock}
+` : "";
+    const effectiveMax = maxLength - prefix.length;
+    if (remaining.length <= effectiveMax) {
+      chunks.push(prefix + remaining);
+      break;
+    }
+    let splitAt = -1;
+    const searchArea = remaining.slice(0, effectiveMax);
+    const paraIdx = searchArea.lastIndexOf("\n\n");
+    if (paraIdx > effectiveMax * 0.3) {
+      splitAt = paraIdx;
+    }
+    if (splitAt === -1) {
+      const newlineIdx = searchArea.lastIndexOf("\n");
+      if (newlineIdx > effectiveMax * 0.3) {
+        splitAt = newlineIdx;
+      }
+    }
+    if (splitAt === -1) {
+      splitAt = effectiveMax;
+    }
+    let chunk = remaining.slice(0, splitAt);
+    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
+    const fenceMatches = chunk.match(/```/g);
+    const fenceCount = fenceMatches ? fenceMatches.length : 0;
+    if (openCodeBlock) {
+      chunk = prefix + chunk;
+      if (fenceCount % 2 === 1) {
+        openCodeBlock = null;
+      } else {
+        chunk += "\n```";
+      }
+    } else {
+      if (fenceCount % 2 === 1) {
+        const lastFenceIdx = chunk.lastIndexOf("```");
+        const afterFence = chunk.slice(lastFenceIdx + 3);
+        const langMatch = afterFence.match(/^(\w*)/);
+        openCodeBlock = "```" + (langMatch?.[1] ?? "");
+        chunk += "\n```";
+      }
+    }
+    chunks.push(chunk);
+  }
+  return chunks.length === 0 ? [""] : chunks;
+}
+function createSplitMessageMiddleware(sendFn, maxLength = TELEGRAM_MAX) {
+  return async (message, next) => {
+    const chunks = splitText(message.text, maxLength);
+    if (chunks.length <= 1) {
+      await next();
+      return;
+    }
+    for (let i = 0; i < chunks.length; i++) {
+      await sendFn({
+        ...message,
+        text: chunks[i],
+        replyTo: i === 0 ? message.replyTo : void 0
+      });
+      if (i < chunks.length - 1) {
+        await new Promise((r) => setTimeout(r, 50));
+      }
+    }
+  };
+}
+
+// ../channels/dist/middleware/error-handler.js
+function isRetryable(error) {
+  if (error instanceof Error) {
+    const err = error;
+    const status = err.status ?? err.error_code;
+    if (status === 429 || status !== void 0 && status >= 500)
+      return true;
+    if (status !== void 0 && status >= 400 && status < 500)
+      return false;
+    return true;
+  }
+  return false;
+}
+async function withRetry(fn, options) {
+  let lastError;
+  for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isRetryable(err) || attempt === options.maxRetries) {
+        throw err;
+      }
+      const delay = options.baseDelayMs * Math.pow(2, attempt);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}
+
+// ../channels/dist/middleware/markdown-to-html.js
+function markdownToTelegramHtml(text) {
+  if (!text)
+    return "";
+  const placeholders = [];
+  const PH_PREFIX = "\uFFFCPH";
+  const PH_SUFFIX = "\uFFFC";
+  function hold(html) {
+    const idx = placeholders.length;
+    placeholders.push(html);
+    return `${PH_PREFIX}${idx}${PH_SUFFIX}`;
+  }
+  let out = text;
+  out = out.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => hold(lang ? `<pre><code class="language-${escapeHtml(lang)}">${escapeHtml(code.trimEnd())}</code></pre>` : `<pre>${escapeHtml(code.trimEnd())}</pre>`));
+  out = out.replace(/`([^`\n]+)`/g, (_, code) => hold(`<code>${escapeHtml(code)}</code>`));
+  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, linkText, url) => hold(`<a href="${escapeHtml(url)}">${escapeHtml(linkText)}</a>`));
+  out = escapeHtml(out);
+  out = out.replace(/\*\*\*(.+?)\*\*\*/g, "<b><i>$1</i></b>");
+  out = out.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+  out = out.replace(/\*([^*\n]+?)\*/g, "<i>$1</i>");
+  out = out.replace(/~~(.+?)~~/g, "<s>$1</s>");
+  out = out.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
+  out = out.replace(/^&gt;\s?(.*)$/gm, "<blockquote>$1</blockquote>");
+  out = out.replace(/<\/blockquote>\n<blockquote>/g, "\n");
+  const phPattern = new RegExp(`${PH_PREFIX}(\\d+)${PH_SUFFIX}`, "g");
+  out = out.replace(phPattern, (_, idx) => placeholders[Number(idx)]);
+  return out;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// ../channels/dist/telegram/media.js
+function registerMediaHandlers(bot, isAllowed, handlers, onRejected) {
+  bot.on("message:photo", async (ctx) => {
+    const userId = ctx.from.id;
+    if (!isAllowed(userId)) {
+      onRejected?.(userId, new Date(ctx.message.date * 1e3));
+      return;
+    }
+    const photos = ctx.message.photo;
+    const largest = photos[photos.length - 1];
+    const attachment = {
+      type: "photo",
+      fileId: largest.file_id,
+      caption: ctx.message.caption ?? void 0
+    };
+    const incoming = {
+      id: String(ctx.message.message_id),
+      channelType: "telegram",
+      userId: String(userId),
+      text: ctx.message.caption ?? "[Photo]",
+      timestamp: new Date(ctx.message.date * 1e3),
+      replyTo: ctx.message.reply_to_message ? String(ctx.message.reply_to_message.message_id) : void 0,
+      attachments: [attachment]
+    };
+    for (const handler of handlers) {
+      await handler(incoming);
+    }
+  });
+  bot.on("message:document", async (ctx) => {
+    const userId = ctx.from.id;
+    if (!isAllowed(userId)) {
+      onRejected?.(userId, new Date(ctx.message.date * 1e3));
+      return;
+    }
+    const doc = ctx.message.document;
+    const attachment = {
+      type: "document",
+      fileId: doc.file_id,
+      fileName: doc.file_name ?? void 0,
+      mimeType: doc.mime_type ?? void 0,
+      caption: ctx.message.caption ?? void 0
+    };
+    const incoming = {
+      id: String(ctx.message.message_id),
+      channelType: "telegram",
+      userId: String(userId),
+      text: ctx.message.caption ?? `[Document: ${doc.file_name ?? "unknown"}]`,
+      timestamp: new Date(ctx.message.date * 1e3),
+      replyTo: ctx.message.reply_to_message ? String(ctx.message.reply_to_message.message_id) : void 0,
+      attachments: [attachment]
+    };
+    for (const handler of handlers) {
+      await handler(incoming);
+    }
+  });
+}
+
+// ../channels/dist/telegram/telegram.js
+var TelegramChannel = class {
+  type = "telegram";
+  bot;
+  allowedUsers;
+  handlers = [];
+  approvalHandlers = [];
+  sendPipeline;
+  log;
+  constructor(config) {
+    this.log = config.logger ?? noopLogger;
+    this.bot = new Bot(config.botToken);
+    this.allowedUsers = new Set(config.allowedUsers);
+    this.bot.catch((err) => {
+      this.log.error("Bot error:", err.message ?? err);
+    });
+    this.bot.on("message:text", async (ctx) => {
+      const userId = ctx.from.id;
+      if (!this.isUserAllowed(userId)) {
+        this.handleRejected(userId, ctx.message.date, config.rejectMessage);
+        return;
+      }
+      const incoming = {
+        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);
+      }
+    });
+    registerMediaHandlers(this.bot, (id) => this.isUserAllowed(id), this.handlers, (userId, ts) => this.handleRejected(userId, Math.floor(ts.getTime() / 1e3), config.rejectMessage));
+    this.bot.on("callback_query:data", async (ctx) => {
+      if (!this.isUserAllowed(ctx.from.id)) {
+        await ctx.answerCallbackQuery({ text: "Not authorized" });
+        return;
+      }
+      const data = ctx.callbackQuery.data;
+      const match = /^(approve|reject):(.+)$/.exec(data);
+      if (!match)
+        return;
+      const [, action, requestId] = match;
+      const approved = action === "approve";
+      const userId = String(ctx.from.id);
+      await ctx.answerCallbackQuery({ text: approved ? "Approved" : "Rejected" });
+      try {
+        await ctx.editMessageReplyMarkup({ reply_markup: void 0 });
+        const originalText = ctx.callbackQuery.message && "text" in ctx.callbackQuery.message ? ctx.callbackQuery.message.text ?? "" : "";
+        await ctx.editMessageText(`${originalText}
+
+${approved ? "Approved" : "Rejected"}`);
+      } catch {
+      }
+      for (const handler of this.approvalHandlers) {
+        handler({ requestId, approved, userId });
+      }
+    });
+    const convertAndSend = async (msg) => {
+      const htmlText = markdownToTelegramHtml(msg.text);
+      const replyOpts = msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {};
+      await withRetry(() => this.bot.api.sendMessage(Number(msg.userId), htmlText, {
+        parse_mode: "HTML",
+        ...replyOpts
+      }), { maxRetries: 3, baseDelayMs: 500 }).catch(async () => {
+        await this.bot.api.sendMessage(Number(msg.userId), msg.text, replyOpts).catch((fallbackErr) => {
+          this.log.error("Fallback send also failed:", fallbackErr);
+          throw fallbackErr;
+        });
+      });
+    };
+    this.sendPipeline = createOutgoingPipeline([createSplitMessageMiddleware(convertAndSend)], convertAndSend);
+  }
+  isUserAllowed(userId) {
+    return this.allowedUsers.has(userId);
+  }
+  handleRejected(userId, unixTimestamp, rejectMessage) {
+    this.log.warn(`Rejected message from unauthorized user ${userId} at ${new Date(unixTimestamp * 1e3).toISOString()}`);
+    if (rejectMessage) {
+      this.bot.api.sendMessage(userId, rejectMessage).catch(() => {
+      });
+    }
+  }
+  onMessage(handler) {
+    this.handlers.push(handler);
+  }
+  async start() {
+    await this.bot.start();
+  }
+  async stop() {
+    await this.bot.stop();
+  }
+  async send(message) {
+    await this.sendPipeline(message);
+  }
+  async sendApprovalRequest(userId, text, buttons, _requestId) {
+    const keyboard = new InlineKeyboard();
+    for (const btn of buttons) {
+      keyboard.text(btn.label, btn.callbackData);
+    }
+    await this.bot.api.sendMessage(Number(userId), text, {
+      reply_markup: keyboard
+    });
+  }
+  onApprovalResponse(handler) {
+    this.approvalHandlers.push(handler);
+  }
+};
+
+// ../core/dist/main.js
+import Dockerode from "dockerode";
+import { resolve } from "path";
+import { createRequire } from "module";
+
+// ../core/dist/version-checker.js
+var VersionChecker = class _VersionChecker {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Check npm registry for latest version */
+  async check() {
+    try {
+      const response = await fetch(`https://registry.npmjs.org/${this.config.packageName}/latest`);
+      if (!response.ok) {
+        return {
+          updateAvailable: false,
+          currentVersion: this.config.currentVersion,
+          error: `npm registry returned ${response.status}`
+        };
+      }
+      const data = await response.json();
+      const latest = data.version;
+      return {
+        updateAvailable: _VersionChecker.compareVersions(this.config.currentVersion, latest) < 0,
+        currentVersion: this.config.currentVersion,
+        latestVersion: latest
+      };
+    } catch (err) {
+      return {
+        updateAvailable: false,
+        currentVersion: this.config.currentVersion,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /** Compare two semver strings (MAJOR.MINOR.PATCH only, pre-release suffixes stripped). Returns -1 if a < b, 0 if equal, 1 if a > b */
+  static compareVersions(a, b) {
+    const clean = (v) => v.replace(/^v/, "").split("-")[0];
+    const pa = clean(a).split(".").map(Number);
+    const pb = clean(b).split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+      const va = pa[i] ?? 0;
+      const vb = pb[i] ?? 0;
+      if (va < vb)
+        return -1;
+      if (va > vb)
+        return 1;
+    }
+    return 0;
+  }
+};
+
+// ../core/dist/main.js
+var 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.
+
+## 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,
+    logger: logger.child("llm")
+  });
+}
+async function startAgent(configPath, opts) {
+  const log = createLogger({ level: opts?.debug ? "debug" : "info" });
+  const config = await loadConfig(configPath);
+  log.info(`Loaded config: ${config.identity.name}`);
+  log.debug(`Config path: ${configPath}`);
+  let telegram;
+  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);
+  log.info(`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(datetimeTool);
+  tools.register(webSearchTool);
+  tools.register(httpTool);
+  tools.register(emailTool);
+  tools.register(sandboxExecTool);
+  tools.register(opencodeTool);
+  tools.register(githubTool);
+  let browserManager;
+  if (config.tools?.browser) {
+    const browserLlm = config.llm.coding ?? config.llm.default;
+    browserManager = new BrowserSessionManager({
+      config: config.tools.browser,
+      llm: {
+        provider: browserLlm.provider ?? config.llm.default.provider,
+        apiKey: browserLlm.apiKey ?? config.llm.default.apiKey,
+        model: browserLlm.model ?? config.llm.default.model,
+        maxTokens: browserLlm.maxTokens ?? config.llm.default.maxTokens
+      },
+      ttlMs: 12e4,
+      logger: log.child("browser")
+    });
+    tools.register(createBrowserTool(browserManager));
+    log.info("Browser tool registered", { provider: config.tools.browser.provider });
+  }
+  const jobStorePath = resolve(configPath, "..", "jobs.json");
+  const jobStore = new JobStore(jobStorePath);
+  const scheduler = new CronScheduler({ store: jobStore, logger: log.child("scheduler") });
+  await scheduler.loadPersistedJobs();
+  log.info(`Loaded ${scheduler.listJobs().length} persisted jobs`);
+  for (const job of config.scheduler.jobs) {
+    if (!scheduler.listJobs().some((j) => j.id === job.id)) {
+      scheduler.addJob({ ...job, enabled: true });
+    }
+  }
+  const docker = new Dockerode();
+  const sandboxImage = config.sandbox.image ?? "augure-sandbox:latest";
+  const sandboxLog = log.child("sandbox");
+  await ensureImage(docker, sandboxImage, sandboxLog);
+  const pool = new DockerContainerPool(docker, {
+    image: sandboxImage,
+    maxTotal: config.security.maxConcurrentSandboxes,
+    logger: sandboxLog
+  });
+  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", log);
+    const skillManager = new SkillManager(skillsPath);
+    const skillGenerator = new SkillGenerator(codingLLM);
+    const skillRunner = new SkillRunner({
+      pool,
+      manager: skillManager,
+      defaults: config.sandbox.defaults,
+      browserManager
+    });
+    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();
+    if (hub && config.updates?.skills?.enabled !== false) {
+      skillUpdater = new SkillUpdater({
+        manager: skillManager,
+        hub,
+        tester: skillTester
+      });
+      try {
+        const updateResults = await skillUpdater.checkAndApply();
+        const updated = updateResults.filter((r) => r.success);
+        const failed = updateResults.filter((r) => !r.success);
+        if (updated.length > 0) {
+          log.info(`Skills updated: ${updated.map((r) => `${r.skillId} (v${r.fromVersion}\u2192v${r.toVersion})`).join(", ")}`);
+        }
+        if (failed.length > 0) {
+          log.warn(`Skill updates failed: ${failed.map((r) => `${r.skillId}: ${r.error}`).join(", ")}`);
+        }
+      } catch (err) {
+        log.error("Skill update check failed:", err);
+      }
+    }
+    skillManagerRef = skillManager;
+    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, 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();
+    log.info(`Personas: ${personaPath}`);
+  }
+  let cliVersion;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkg = require2("augure/package.json");
+    cliVersion = pkg.version;
+  } catch {
+  }
+  if (cliVersion && config.updates?.cli?.enabled !== false) {
+    const versionChecker = new VersionChecker({
+      currentVersion: cliVersion,
+      packageName: "augure"
+    });
+    const versionResult = await versionChecker.check();
+    if (versionResult.updateAvailable) {
+      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 activeChannel = telegram;
+  const approvalGate = config.approval?.enabled && activeChannel ? new ApprovalGate({
+    channel: activeChannel,
+    timeoutMs: config.approval.timeoutMs,
+    logger: log.child("approval")
+  }) : void 0;
+  if (approvalGate) {
+    log.info(`Approval gate enabled (timeout: ${config.approval.timeoutMs ?? 12e4}ms)`);
+  }
+  const agent = new Agent({
+    llm,
+    tools,
+    systemPrompt,
+    memoryContent: "",
+    retriever,
+    ingester,
+    audit,
+    guard,
+    modelName: config.llm.default.model,
+    logger: log.child("agent"),
+    codeModeExecutor,
+    approvalGate
+  });
+  const heartbeatIntervalMs = parseInterval(config.scheduler.heartbeatInterval);
+  const heartbeat = new Heartbeat({
+    llm: monitoringLLM,
+    memory,
+    intervalMs: heartbeatIntervalMs,
+    logger: log.child("heartbeat"),
+    onAction: async (action) => {
+      log.info(`Heartbeat action: ${action}`);
+      const response = await agent.handleMessage({
+        id: `heartbeat-${Date.now()}`,
+        channelType: "system",
+        userId: "system",
+        text: `[Heartbeat] ${action}`,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      log.debug(`Heartbeat response: ${response.slice(0, 200)}`);
+    }
+  });
+  scheduler.onJobTrigger(async (job) => {
+    log.info(`Job triggered: ${job.id}`);
+    const response = await agent.handleMessage({
+      id: `job-${job.id}-${Date.now()}`,
+      channelType: "system",
+      userId: "system",
+      text: job.prompt,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (telegram && config.channels.telegram?.enabled) {
+      const userId = config.channels.telegram.allowedUsers[0];
+      if (userId !== void 0) {
+        await telegram.send({
+          channelType: "telegram",
+          userId: String(userId),
+          text: response
+        });
+      }
+    }
+    log.debug(`Job ${job.id} completed`);
+  });
+  scheduler.start();
+  heartbeat.start();
+  log.info(`Scheduler started: ${scheduler.listJobs().length} jobs, heartbeat every ${config.scheduler.heartbeatInterval}`);
+  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,
+      logger: telegramLog
+    });
+    const tg = telegram;
+    const commandCtx = {
+      scheduler,
+      pool,
+      agent,
+      skillManager: skillManagerRef
+    };
+    tg.onMessage(async (msg) => {
+      log.info(`Message from ${msg.userId}: ${msg.text}`);
+      try {
+        const cmdResult = await handleCommand(msg.text, commandCtx);
+        if (cmdResult.handled) {
+          await tg.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 tg.send({
+          channelType: "telegram",
+          userId: msg.userId,
+          text: response,
+          replyTo: msg.id
+        });
+      } catch (err) {
+        log.error("Error handling message:", err);
+        await tg.send({
+          channelType: "telegram",
+          userId: msg.userId,
+          text: "An error occurred while processing your message."
+        });
+      }
+    });
+    log.info("Telegram bot starting...");
+  }
+  const updateTimers = [];
+  if (skillUpdater && config.updates?.skills?.checkInterval) {
+    const su = skillUpdater;
+    const skillCheckMs = parseInterval(config.updates.skills.checkInterval);
+    updateTimers.push(setInterval(async () => {
+      try {
+        const results = await su.checkAndApply();
+        for (const r of results) {
+          if (r.success) {
+            log.info(`Skill auto-updated: ${r.skillId} v${r.fromVersion}\u2192v${r.toVersion}`);
+          } else if (r.rolledBack) {
+            log.warn(`Skill update rolled back: ${r.skillId} - ${r.error}`);
+          }
+        }
+      } catch (err) {
+        log.error("Periodic skill update check failed:", err);
+      }
+    }, skillCheckMs));
+  }
+  if (cliVersion && config.updates?.cli?.enabled !== false && config.channels.telegram?.enabled) {
+    const cliCheckMs = parseInterval(config.updates?.cli?.checkInterval ?? "24h");
+    const versionChecker = new VersionChecker({
+      currentVersion: cliVersion,
+      packageName: "augure"
+    });
+    updateTimers.push(setInterval(async () => {
+      try {
+        const result = await versionChecker.check();
+        if (result.updateAvailable && telegram) {
+          const userId = config.channels.telegram?.allowedUsers[0];
+          if (userId !== void 0) {
+            await telegram.send({
+              channelType: "telegram",
+              userId: String(userId),
+              text: `Update available: Augure v${result.latestVersion} (current: v${result.currentVersion}).
+Run: \`npm update -g augure\``
+            });
+          }
+        }
+      } catch (err) {
+        log.error("CLI version check failed:", err);
+      }
+    }, cliCheckMs));
+  }
+  let mcpHttpServer;
+  if (config.mcp?.enabled || opts?.mcp) {
+    const { createMcpServer: createMcpServer2 } = await import("./mcp-server-AUASYDPU.js");
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    const { createServer } = await import("http");
+    const mcpPort = config.mcp?.port ?? 3100;
+    const mcpServer = createMcpServer2({
+      tools,
+      memory,
+      scheduler,
+      personaResolver,
+      logger: log.child("mcp")
+    });
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => crypto.randomUUID() });
+    await mcpServer.connect(transport);
+    mcpHttpServer = createServer(async (req, res) => {
+      if (req.url === "/mcp") {
+        await transport.handleRequest(req, res);
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    mcpHttpServer.listen(mcpPort);
+    log.info(`MCP server listening on port ${mcpPort}`);
+  }
+  const shutdown = async () => {
+    log.info("Shutting down...");
+    for (const timer of updateTimers)
+      clearInterval(timer);
+    heartbeat.stop();
+    scheduler.stop();
+    if (mcpHttpServer)
+      mcpHttpServer.close();
+    if (telegram)
+      await telegram.stop();
+    if (browserManager)
+      await browserManager.closeAll();
+    await pool.destroyAll();
+    await audit.close();
+    log.info("All containers destroyed");
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  if (telegram) {
+    await telegram.start();
+  }
+}
+
+export {
+  loadConfig,
+  OpenRouterClient,
+  assembleContext,
+  summarize,
+  FileAuditLogger,
+  NullAuditLogger,
+  Agent,
+  handleCommand,
+  PersonaResolver,
+  ContextGuard,
+  ApprovalGate,
+  createLogger,
+  VersionChecker,
+  startAgent
+};