augure 0.7.0 → 0.8.0

package/dist/bin.js

@@ -223,7 +223,22 @@ var AppConfigSchema = z.object({
         password: z.string()
       })
     }).optional(),
-    github: z.object({ token: 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(),
@@ -261,6 +276,10 @@ var AppConfigSchema = 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()
 });
 function interpolateEnvVars(raw) {
@@ -607,7 +626,7 @@ var VmExecutor = class {
 
 // ../code-mode/dist/docker-sandbox.js
 var DOCKER_HARNESS = `
-import { readFile } from "node:fs/promises";
+import { readFile, writeFile, unlink } from "node:fs/promises";
 
 const __logs = [];
 const __originalLog = console.log;
@@ -616,12 +635,28 @@ 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 () => {
+    return async (args) => {
       __toolCalls++;
-      return { success: false, output: "Tool calls not yet supported in Docker executor" };
+      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\`);
     };
   }
 });
@@ -648,11 +683,37 @@ try {
   }));
 }
 `;
+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;
@@ -679,10 +740,14 @@ var DockerExecutor = class {
       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();
@@ -937,6 +1002,18 @@ var Agent = class {
       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, {});
@@ -1151,6 +1228,60 @@ var ContextGuard = class {
   }
 };
 
+// ../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((resolve5) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        this.log.warn(`Approval timed out for ${toolName} (request ${requestId})`);
+        resolve5(false);
+      }, this.timeoutMs);
+      this.pending.set(requestId, {
+        resolve: (approved) => {
+          clearTimeout(timer);
+          resolve5(approved);
+        }
+      });
+    });
+    await this.channel.sendApprovalRequest(userId, text, buttons, requestId);
+    return resultPromise;
+  }
+};
+
 // ../core/dist/logger.js
 import { styleText } from "util";
 var LEVELS = {
@@ -1202,7 +1333,7 @@ function createLogger(opts = {}) {
 }
 
 // ../channels/dist/telegram/telegram.js
-import { Bot } from "grammy";
+import { Bot, InlineKeyboard } from "grammy";
 
 // ../channels/dist/pipeline.js
 function createOutgoingPipeline(middlewares, send) {
@@ -1420,6 +1551,7 @@ var TelegramChannel = class {
   bot;
   allowedUsers;
   handlers = [];
+  approvalHandlers = [];
   sendPipeline;
   log;
   constructor(config) {
@@ -1448,6 +1580,31 @@ var TelegramChannel = class {
       }
     });
     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 handler2 of this.approvalHandlers) {
+        handler2({ requestId, approved, userId });
+      }
+    });
     const convertAndSend = async (msg) => {
       const htmlText = markdownToTelegramHtml(msg.text);
       const replyOpts = msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {};
@@ -1485,6 +1642,18 @@ var TelegramChannel = class {
   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(handler2) {
+    this.approvalHandlers.push(handler2);
+  }
 };
 
 // ../tools/dist/registry.js
@@ -2192,6 +2361,7 @@ var emailTool = {
 var sandboxExecTool = {
   name: "sandbox_exec",
   description: "Execute a shell command in an isolated Docker container. Returns stdout, stderr, and exit code.",
+  riskLevel: "high",
   parameters: {
     type: "object",
     properties: {
@@ -2265,6 +2435,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.",
+  riskLevel: "high",
   configCheck: (ctx) => ctx.config.sandbox.codeAgent ? null : "This tool requires sandbox.codeAgent configuration. See https://augure.dev/docs/sandbox",
   parameters: {
     type: "object",
@@ -6345,6 +6516,248 @@ var githubTool = {
   }
 };
 
+// ../tools/dist/browser.js
+function createBrowserTool(manager) {
+  return {
+    name: "browser",
+    description: "AI-powered browser automation. Open a session, then use natural language to interact with web pages. Actions: open (creates session), navigate, act (click/type/interact), extract (get structured data), observe (discover elements), screenshot, close. Use 'act' with natural language instructions instead of CSS selectors. Use 'extract' with an instruction describing what data to get. Always close sessions when done.",
+    parameters: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["open", "navigate", "act", "extract", "observe", "screenshot", "close"],
+          description: "The browser action to perform"
+        },
+        session: {
+          type: "string",
+          description: "Session ID from 'open'. Required for all actions except 'open'."
+        },
+        url: {
+          type: "string",
+          description: "URL to navigate to. Used with 'open' and 'navigate'."
+        },
+        instruction: {
+          type: "string",
+          description: "Natural language instruction for act/extract/observe. Examples: 'click the search button', 'extract all product prices and titles', 'find the login form'."
+        },
+        schema: {
+          type: "object",
+          description: "JSON schema for structured extraction with 'extract'. Optional."
+        },
+        variables: {
+          type: "object",
+          description: "Variables for sensitive data in 'act'. Use %varName% in instruction. Example: instruction='type %password%', variables={password: 'secret'}"
+        }
+      },
+      required: ["action"]
+    },
+    configCheck: (ctx) => {
+      if (!ctx.config.tools?.browser) {
+        return "Browser tool requires tools.browser config in augure.json5. Set provider to 'local' for Playwright or 'browserbase' for cloud.";
+      }
+      if (ctx.config.tools.browser.provider === "browserbase" && !ctx.config.tools.browser.browserbase?.apiKey) {
+        return "Browserbase provider requires tools.browser.browserbase.apiKey";
+      }
+      return null;
+    },
+    execute: async (params, _ctx) => {
+      const p = params;
+      if (p.action !== "open" && !p.session) {
+        return { success: false, output: "Missing 'session' \u2014 open a session first with action: 'open'" };
+      }
+      if (["act", "extract", "observe"].includes(p.action) && !p.instruction) {
+        return { success: false, output: `Missing 'instruction' for action '${p.action}'` };
+      }
+      try {
+        switch (p.action) {
+          case "open": {
+            const sessionId = await manager.open(p.url);
+            return { success: true, output: `Session ${sessionId} opened.${p.url ? ` Navigated to ${p.url}` : ""}` };
+          }
+          case "navigate": {
+            if (!p.url)
+              return { success: false, output: "Missing 'url' for navigate" };
+            await manager.navigate(p.session, p.url);
+            return { success: true, output: `Navigated to ${p.url}` };
+          }
+          case "act": {
+            const result = await manager.act(p.session, p.instruction, p.variables);
+            return { success: result.success, output: result.message || "Action completed" };
+          }
+          case "extract": {
+            const data = await manager.extract(p.session, p.instruction, p.schema);
+            const output = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+            return { success: true, output };
+          }
+          case "observe": {
+            const elements = await manager.observe(p.session, p.instruction);
+            return {
+              success: true,
+              output: elements.length > 0 ? elements.map((e) => `- ${e.description} (${e.selector})`).join("\n") : "No matching elements found"
+            };
+          }
+          case "screenshot": {
+            const base64 = await manager.screenshot(p.session);
+            return {
+              success: true,
+              output: "Screenshot captured",
+              artifacts: [{ type: "image", name: "screenshot.png", content: base64 }]
+            };
+          }
+          case "close": {
+            await manager.close(p.session);
+            return { success: true, output: `Session ${p.session} closed` };
+          }
+          default:
+            return { success: false, output: `Unknown action: ${p.action}` };
+        }
+      } catch (err2) {
+        return {
+          success: false,
+          output: `Browser error: ${err2 instanceof Error ? err2.message : String(err2)}`
+        };
+      }
+    }
+  };
+}
+
+// ../browser/dist/session-manager.js
+import { Stagehand } from "@browserbasehq/stagehand";
+
+// ../browser/dist/provider.js
+var PROVIDER_BASE_URLS = {
+  openrouter: "https://openrouter.ai/api/v1",
+  anthropic: "https://api.anthropic.com/v1",
+  openai: "https://api.openai.com/v1"
+};
+function createStagehandConfig(config, llm) {
+  const baseURL = PROVIDER_BASE_URLS[llm.provider];
+  return {
+    env: config.provider === "local" ? "LOCAL" : "BROWSERBASE",
+    apiKey: config.browserbase?.apiKey,
+    projectId: config.browserbase?.projectId,
+    model: {
+      modelName: llm.model,
+      apiKey: llm.apiKey,
+      ...baseURL ? { baseURL } : {}
+    },
+    localBrowserLaunchOptions: config.provider === "local" ? {
+      headless: config.defaults?.headless ?? true,
+      viewport: config.defaults?.viewport ?? { width: 1280, height: 720 }
+    } : void 0,
+    domSettleTimeout: (config.defaults?.timeout ?? 30) * 1e3,
+    verbose: 0,
+    disablePino: true
+  };
+}
+
+// ../browser/dist/session-manager.js
+var BrowserSessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  config;
+  llm;
+  ttlMs;
+  log;
+  counter = 0;
+  constructor(opts) {
+    this.config = opts.config;
+    this.llm = opts.llm;
+    this.ttlMs = opts.ttlMs ?? 12e4;
+    this.log = opts.logger ?? noopLogger;
+  }
+  async open(url) {
+    const id = `s_${Date.now()}_${++this.counter}`;
+    const stagehandConfig = createStagehandConfig(this.config, this.llm);
+    const stagehand = new Stagehand(stagehandConfig);
+    await stagehand.init();
+    if (url) {
+      const page = stagehand.context.activePage();
+      if (!page)
+        throw new Error(`No active page after init for session ${id}`);
+      await page.goto(url, { waitUntil: "domcontentloaded" });
+    }
+    const timer = setTimeout(() => {
+      this.log.warn(`Browser session ${id} expired (TTL ${this.ttlMs}ms)`);
+      this.close(id).catch(() => {
+      });
+    }, this.ttlMs);
+    this.sessions.set(id, { stagehand, timer });
+    this.log.info(`Browser session ${id} opened`);
+    return id;
+  }
+  async navigate(sessionId, url) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    const page = entry.stagehand.context.activePage();
+    if (!page)
+      throw new Error(`No active page for session ${sessionId}`);
+    await page.goto(url, { waitUntil: "domcontentloaded" });
+  }
+  async act(sessionId, instruction, variables) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    const result = await entry.stagehand.act(instruction, variables ? { variables } : void 0);
+    return { success: result.success, message: result.message ?? result.actionDescription ?? "" };
+  }
+  async extract(sessionId, instruction, schema) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    if (schema) {
+      return entry.stagehand.extract(instruction, schema);
+    }
+    return entry.stagehand.extract(instruction);
+  }
+  async observe(sessionId, instruction) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    const actions2 = await entry.stagehand.observe(instruction);
+    return actions2.map((a) => ({
+      description: a.description ?? "",
+      selector: a.selector ?? ""
+    }));
+  }
+  async screenshot(sessionId) {
+    const entry = this.getSession(sessionId);
+    this.resetTtl(sessionId, entry);
+    const page = entry.stagehand.context.activePage();
+    if (!page)
+      throw new Error(`No active page for session ${sessionId}`);
+    const buffer = await page.screenshot();
+    return Buffer.from(buffer).toString("base64");
+  }
+  async close(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry)
+      return;
+    clearTimeout(entry.timer);
+    this.sessions.delete(sessionId);
+    try {
+      await entry.stagehand.close();
+    } catch {
+    }
+    this.log.info(`Browser session ${sessionId} closed`);
+  }
+  async closeAll() {
+    const ids = [...this.sessions.keys()];
+    await Promise.all(ids.map((id) => this.close(id)));
+  }
+  getSession(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry)
+      throw new Error(`Unknown or expired: no browser session ${sessionId}`);
+    return entry;
+  }
+  resetTtl(sessionId, entry) {
+    clearTimeout(entry.timer);
+    entry.timer = setTimeout(() => {
+      this.log.warn(`Browser session ${sessionId} expired (TTL ${this.ttlMs}ms)`);
+      this.close(sessionId).catch(() => {
+      });
+    }, this.ttlMs);
+  }
+};
+
 // ../core/dist/main.js
 import Dockerode from "dockerode";
 
@@ -6846,15 +7259,25 @@ ${content}`;
 // ../scheduler/dist/cron.js
 import { createTask, validate } from "node-cron";
 var CronScheduler = class {
-  store;
   jobs = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
   timers = /* @__PURE__ */ new Map();
   handlers = [];
   persistChain = Promise.resolve();
   running = false;
-  constructor(store) {
-    this.store = store;
+  store;
+  log;
+  constructor(storeOrOpts) {
+    if (storeOrOpts && "save" in storeOrOpts) {
+      this.store = storeOrOpts;
+      this.log = noopLogger;
+    } else if (storeOrOpts) {
+      const opts = storeOrOpts;
+      this.store = opts.store;
+      this.log = opts.logger ?? noopLogger;
+    } else {
+      this.log = noopLogger;
+    }
   }
   onJobTrigger(handler2) {
     this.handlers.push(handler2);
@@ -6870,20 +7293,24 @@ 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}`})`);
+    this.log.info(`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);
+        this.log.info(`Cron fired for job ${job.id}`);
+        this.executeHandlers(job).catch((err2) => this.log.error(`Cron job ${job.id} handler failed:`, err2));
       });
       if (this.running) {
         task.start();
-        console.log(`[scheduler] Started cron task for ${job.id} immediately (scheduler already running)`);
+        this.log.debug(`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);
+    if (job.enabled && job.runAt && !job.cron) {
+      if (this.running) {
+        this.scheduleOneShot(job);
+      } else {
+        this.log.warn(`Scheduler not running \u2014 one-shot job ${job.id} will be scheduled on start()`);
+      }
     }
     this.persist();
   }
@@ -6899,7 +7326,7 @@ var CronScheduler = class {
       this.timers.delete(id);
     }
     this.jobs.delete(id);
-    console.log(`[scheduler] Removed job ${id}`);
+    this.log.debug(`Removed job ${id}`);
     this.persist();
   }
   listJobs() {
@@ -6916,10 +7343,10 @@ var CronScheduler = class {
     if (!this.store)
       return;
     const jobs = await this.store.load();
-    console.log(`[scheduler] Loading ${jobs.length} persisted jobs`);
+    this.log.info(`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})`);
+        this.log.debug(`Skipping expired one-shot job ${job.id} (runAt: ${job.runAt})`);
         continue;
       }
       this.addJob(job);
@@ -6927,10 +7354,10 @@ var CronScheduler = class {
   }
   start() {
     this.running = true;
-    console.log(`[scheduler] Starting with ${this.tasks.size} cron tasks and ${this.handlers.length} handlers`);
+    this.log.info(`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}`);
+      this.log.debug(`Started cron task: ${id}`);
     }
     for (const job of this.jobs.values()) {
       if (job.enabled && job.runAt && !job.cron) {
@@ -6939,6 +7366,7 @@ var CronScheduler = class {
     }
   }
   stop() {
+    this.log.info("Scheduler stopped");
     this.running = false;
     for (const task of this.tasks.values()) {
       task.stop();
@@ -6951,16 +7379,14 @@ var CronScheduler = class {
   scheduleOneShot(job) {
     const delayMs = Date.parse(job.runAt) - Date.now();
     if (delayMs <= 0) {
-      console.log(`[scheduler] One-shot job ${job.id} already expired (delay: ${delayMs}ms), skipping`);
+      this.log.warn(`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})`);
+    this.log.info(`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.log.info(`One-shot job ${job.id} firing now`);
       this.timers.delete(job.id);
-      void this.executeHandlers(job).then(() => {
-        this.removeJob(job.id);
-      });
+      this.executeHandlers(job).then(() => this.removeJob(job.id)).catch((err2) => this.log.error(`One-shot job ${job.id} handler failed:`, err2));
     }, delayMs);
     this.timers.set(job.id, timer);
   }
@@ -6971,7 +7397,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}`);
+    this.log.debug(`Executing ${this.handlers.length} handlers for job ${job.id}`);
     for (const handler2 of this.handlers) {
       await handler2(job);
     }
@@ -8081,6 +8507,7 @@ function createSkillTools(deps) {
   const manageSkillTool = {
     name: "manage_skill",
     description: "Manage a skill: pause, resume, or delete it",
+    riskLevel: "high",
     parameters: {
       type: "object",
       properties: {
@@ -8468,9 +8895,26 @@ async function startAgent(configPath, opts) {
   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(jobStore);
+  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) {
@@ -8498,7 +8942,8 @@ async function startAgent(configPath, opts) {
     const skillRunner = new SkillRunner({
       pool,
       manager: skillManager,
-      defaults: config.sandbox.defaults
+      defaults: config.sandbox.defaults,
+      browserManager
     });
     const skillTester = new SkillTester({
       pool,
@@ -8616,6 +9061,15 @@ async function startAgent(configPath, opts) {
     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,
@@ -8627,8 +9081,51 @@ async function startAgent(configPath, opts) {
     guard,
     modelName: config.llm.default.model,
     logger: log.child("agent"),
-    codeModeExecutor
+    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({
@@ -8676,51 +9173,8 @@ async function startAgent(configPath, opts) {
         });
       }
     });
-    await tg.start();
-    log.info("Telegram bot started");
+    log.info("Telegram bot starting...");
   }
-  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}`);
   const updateTimers = [];
   if (skillUpdater && config.updates?.skills?.checkInterval) {
     const su = skillUpdater;
@@ -8773,6 +9227,8 @@ Run: \`npm update -g augure\``
     scheduler.stop();
     if (telegram)
       await telegram.stop();
+    if (browserManager)
+      await browserManager.closeAll();
     await pool.destroyAll();
     await audit.close();
     log.info("All containers destroyed");
@@ -8780,6 +9236,9 @@ Run: \`npm update -g augure\``
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
+  if (telegram) {
+    await telegram.start();
+  }
 }
 
 // src/commands/start.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "augure",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Augure — your proactive AI agent",
   "type": "module",
   "bin": {
@@ -22,20 +22,21 @@
     "gray-matter": "^4.0.3",
     "json5": "^2.2.3",
     "node-cron": "^4.2.1",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@browserbasehq/stagehand": "^3.0.0"
   },
   "devDependencies": {
     "@types/dockerode": "^4.0.1",
     "@types/node-cron": "^3.0.11",
     "tsup": "^8.5.1",
-    "@augure/channels": "0.1.3",
-    "@augure/core": "0.6.0",
-    "@augure/sandbox": "0.1.2",
-    "@augure/scheduler": "0.1.2",
-    "@augure/memory": "0.0.5",
-    "@augure/tools": "0.3.0",
-    "@augure/types": "0.3.0",
-    "@augure/skills": "0.1.3"
+    "@augure/channels": "0.2.0",
+    "@augure/core": "0.8.0",
+    "@augure/memory": "0.0.7",
+    "@augure/scheduler": "0.1.5",
+    "@augure/sandbox": "0.1.4",
+    "@augure/skills": "0.1.5",
+    "@augure/tools": "0.4.1",
+    "@augure/types": "0.5.0"
   },
   "keywords": [
     "ai",