open-agents-ai 0.35.2 → 0.37.0

package/dist/index.js

@@ -1285,7 +1285,7 @@ ${stdinInput ?? ""}`);
       }
       runCommand(command, timeout, stdinInput) {
         const start = performance.now();
-        return new Promise((resolve23) => {
+        return new Promise((resolve26) => {
           const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
             env: {
@@ -1313,7 +1313,7 @@ ${stdinInput ?? ""}`);
             clearTimeout(timer);
             if (exitFlushTimer)
               clearTimeout(exitFlushTimer);
-            resolve23(result);
+            resolve26(result);
           };
           const timer = setTimeout(() => {
             killed = true;
@@ -2317,7 +2317,7 @@ Meta: ${metaKeys.map((k) => `${k}="${meta[k]?.slice(0, 80)}"`).join(", ")}`);
         return null;
       }
       runProcess(cmd, args, timeoutMs) {
-        return new Promise((resolve23, reject) => {
+        return new Promise((resolve26, reject) => {
           const proc = execFile3(cmd, args, {
             timeout: timeoutMs,
             maxBuffer: 10 * 1024 * 1024,
@@ -2327,7 +2327,7 @@ Meta: ${metaKeys.map((k) => `${k}="${meta[k]?.slice(0, 80)}"`).join(", ")}`);
               reject(new Error(`Process timeout after ${timeoutMs}ms`));
               return;
             }
-            resolve23({
+            resolve26({
               stdout: String(stdout),
               stderr: String(stderr),
               exitCode: error ? error.code ?? 1 : 0
@@ -2906,6 +2906,10 @@ var init_explore_tools = __esm({
       code_sandbox: "Run code in an isolated sandbox",
       structured_read: "Read structured data files (CSV, JSON)",
       sub_agent: "Delegate a subtask to a new agent instance",
+      browser_action: "Automate headless Chrome: navigate, click, type, screenshot, read DOM",
+      scheduler: "Schedule tasks for automatic future execution via OS cron",
+      reminder: "Set reminders that surface at future agent startups",
+      agenda: "View all pending reminders, scheduled tasks, and attention items",
       background_run: "Run a shell command in the background",
       task_status: "Check status of background tasks",
       task_output: "Read output from a background task",
@@ -5357,7 +5361,7 @@ var init_custom_tool = __esm({
       }
       /** Execute a single shell command and return output */
       runCommand(command) {
-        return new Promise((resolve23) => {
+        return new Promise((resolve26) => {
           const child = spawn3("bash", ["-c", command], {
             cwd: this.workingDir,
             env: { ...process.env, CI: "true", NO_COLOR: "1" },
@@ -5382,11 +5386,11 @@ var init_custom_tool = __esm({
               child.kill("SIGTERM");
             } catch {
             }
-            resolve23({ success: false, output: stdout, error: "Command timed out after 60s" });
+            resolve26({ success: false, output: stdout, error: "Command timed out after 60s" });
           }, 6e4);
           child.on("close", (code) => {
             clearTimeout(timer);
-            resolve23({
+            resolve26({
               success: code === 0,
               output: stdout + (stderr && code === 0 ? `
 STDERR:
@@ -5396,7 +5400,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve23({ success: false, output: stdout, error: err.message });
+            resolve26({ success: false, output: stdout, error: err.message });
           });
         });
       }
@@ -6578,7 +6582,7 @@ import { writeFile as writeFile7, mkdtemp, rm, readdir as readdir2, stat } from
 import { join as join16 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 function runProcess(cmd, args, options) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve26) => {
     const proc = spawn5(cmd, args, {
       cwd: options.cwd,
       timeout: options.timeout,
@@ -6608,7 +6612,7 @@ function runProcess(cmd, args, options) {
       }
     });
     proc.on("error", (err) => {
-      resolve23({
+      resolve26({
         stdout,
         stderr: stderr || err.message,
         exitCode: 1,
@@ -6620,7 +6624,7 @@ function runProcess(cmd, args, options) {
       if (signal === "SIGTERM" || signal === "SIGKILL") {
         timedOut = true;
       }
-      resolve23({
+      resolve26({
         stdout,
         stderr,
         exitCode: code ?? (timedOut ? 124 : 1),
@@ -8650,6 +8654,1248 @@ Note: Advanced Python pipeline not available \u2014 install pytesseract, opencv-
   }
 });
 
+// packages/execution/dist/tools/browser-action.js
+import { execSync as execSync15, spawn as spawn7 } from "node:child_process";
+import { existsSync as existsSync18, readFileSync as readFileSync13 } from "node:fs";
+import { join as join21, dirname as dirname8 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+async function probeService() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch(`${BASE_URL}/health`, { signal: controller.signal });
+    clearTimeout(timeout);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+function findPython2() {
+  for (const cmd of ["python3", "python"]) {
+    try {
+      const ver = execSync15(`${cmd} --version 2>&1`, { stdio: "pipe", timeout: 5e3 }).toString().trim();
+      if (ver.includes("Python 3"))
+        return cmd;
+    } catch {
+    }
+  }
+  return null;
+}
+async function launchService() {
+  if (await probeService())
+    return null;
+  const python = findPython2();
+  if (!python)
+    return "Python 3 not found. Install Python 3.9+ to use browser automation.";
+  if (!existsSync18(SCRAPE_SCRIPT)) {
+    return `Scrape service script not found at ${SCRAPE_SCRIPT}`;
+  }
+  serviceProcess = spawn7(python, [SCRAPE_SCRIPT], {
+    stdio: "ignore",
+    detached: true,
+    env: {
+      ...process.env,
+      SCRAPE_PORT: String(DEFAULT_PORT),
+      SCRAPE_HEADLESS_DEFAULT: "1",
+      SCRAPE_REQUIRE_AUTH: "0"
+    }
+  });
+  serviceProcess.unref();
+  for (let i = 0; i < 120; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (await probeService())
+      return null;
+  }
+  return "Scrape service failed to start within 60s. Check Chrome/Chromium installation.";
+}
+async function ensureSession() {
+  if (activeSessionId) {
+    try {
+      const res2 = await fetch(`${BASE_URL}/health`);
+      if (res2.ok)
+        return { sessionId: activeSessionId };
+    } catch {
+    }
+    activeSessionId = null;
+  }
+  const res = await fetch(`${BASE_URL}/session/start`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ headless: true })
+  });
+  const data = await res.json();
+  if (!data.ok)
+    return { error: String(data.message ?? "Failed to start browser session"), sessionId: "" };
+  activeSessionId = data.session_id;
+  return { sessionId: activeSessionId };
+}
+async function apiCall(endpoint, method = "POST", body) {
+  const options = {
+    method,
+    headers: { "Content-Type": "application/json" }
+  };
+  if (body && method === "POST") {
+    options.body = JSON.stringify({ sid: activeSessionId, ...body });
+  }
+  let url = `${BASE_URL}${endpoint}`;
+  if (method === "GET" && activeSessionId) {
+    url += `?sid=${encodeURIComponent(activeSessionId)}`;
+  }
+  const res = await fetch(url, options);
+  return await res.json();
+}
+var __dirname2, SCRAPE_SCRIPT, DEFAULT_PORT, BASE_URL, serviceProcess, activeSessionId, BrowserActionTool;
+var init_browser_action = __esm({
+  "packages/execution/dist/tools/browser-action.js"() {
+    "use strict";
+    __dirname2 = dirname8(fileURLToPath5(import.meta.url));
+    SCRAPE_SCRIPT = join21(__dirname2, "..", "..", "scripts", "web_scrape.py");
+    DEFAULT_PORT = 8130;
+    BASE_URL = `http://localhost:${DEFAULT_PORT}`;
+    serviceProcess = null;
+    activeSessionId = null;
+    BrowserActionTool = class {
+      name = "browser_action";
+      description = "Automate a headless Chrome browser: navigate to URLs, click elements, type text, take screenshots, read DOM content, scroll, and navigate history. Uses a local Selenium-based service that auto-starts on first use. Better than xdotool for web automation \u2014 works headlessly without a display server. Actions: navigate, click, click_xy, type, screenshot, dom, scroll, back, forward, close.";
+      parameters = {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["navigate", "click", "click_xy", "type", "screenshot", "dom", "scroll", "scroll_up", "scroll_down", "back", "forward", "close"],
+            description: "Browser action to perform"
+          },
+          url: {
+            type: "string",
+            description: "URL to navigate to (for 'navigate' action)"
+          },
+          selector: {
+            type: "string",
+            description: "CSS selector of element to interact with (for 'click' and 'type' actions)"
+          },
+          text: {
+            type: "string",
+            description: "Text to type into the selected element (for 'type' action)"
+          },
+          x: {
+            type: "number",
+            description: "X coordinate for click_xy action (viewport pixels)"
+          },
+          y: {
+            type: "number",
+            description: "Y coordinate for click_xy action (viewport pixels)"
+          },
+          amount: {
+            type: "number",
+            description: "Scroll amount in pixels (for 'scroll' action, default 600)"
+          }
+        },
+        required: ["action"]
+      };
+      async execute(args) {
+        const start = Date.now();
+        const action = args.action;
+        const launchErr = await launchService();
+        if (launchErr) {
+          return { success: false, output: "", error: launchErr, durationMs: Date.now() - start };
+        }
+        if (action === "close") {
+          if (activeSessionId) {
+            try {
+              await apiCall("/session/close");
+            } catch {
+            }
+            activeSessionId = null;
+          }
+          return { success: true, output: "Browser session closed.", durationMs: Date.now() - start };
+        }
+        const session = await ensureSession();
+        if (session.error) {
+          return { success: false, output: "", error: session.error, durationMs: Date.now() - start };
+        }
+        try {
+          let result;
+          switch (action) {
+            case "navigate":
+              if (!args.url)
+                return { success: false, output: "", error: "url is required for navigate action", durationMs: Date.now() - start };
+              result = await apiCall("/navigate", "POST", { url: args.url });
+              return {
+                success: !!result.ok,
+                output: result.ok ? `Navigated to ${args.url}` : String(result.message ?? "Navigation failed"),
+                durationMs: Date.now() - start
+              };
+            case "click":
+              if (!args.selector)
+                return { success: false, output: "", error: "selector is required for click action", durationMs: Date.now() - start };
+              result = await apiCall("/click", "POST", { selector: args.selector });
+              return {
+                success: !!result.ok,
+                output: result.ok ? `Clicked element: ${args.selector}` : String(result.message ?? "Click failed"),
+                durationMs: Date.now() - start
+              };
+            case "click_xy":
+              if (args.x == null || args.y == null)
+                return { success: false, output: "", error: "x and y are required for click_xy action", durationMs: Date.now() - start };
+              result = await apiCall("/click_xy", "POST", { x: args.x, y: args.y });
+              return {
+                success: !!result.ok,
+                output: result.ok ? `Clicked at (${args.x}, ${args.y})` : String(result.message ?? "Click failed"),
+                durationMs: Date.now() - start
+              };
+            case "type":
+              if (!args.selector || !args.text)
+                return { success: false, output: "", error: "selector and text are required for type action", durationMs: Date.now() - start };
+              result = await apiCall("/type", "POST", { selector: args.selector, text: args.text });
+              return {
+                success: !!result.ok,
+                output: result.ok ? `Typed "${args.text.slice(0, 50)}" into ${args.selector}` : String(result.message ?? "Type failed"),
+                durationMs: Date.now() - start
+              };
+            case "screenshot": {
+              result = await apiCall("/screenshot", "GET");
+              const b64 = result.b64;
+              const width = result.width;
+              const height = result.height;
+              if (b64) {
+                return {
+                  success: true,
+                  output: `Screenshot captured (${width}x${height}). Base64 length: ${b64.length} chars.
+[IMAGE_BASE64:image/png:${b64.slice(0, 200)}...]`,
+                  durationMs: Date.now() - start
+                };
+              }
+              return { success: false, output: "", error: "Screenshot failed", durationMs: Date.now() - start };
+            }
+            case "dom": {
+              result = await apiCall("/dom", "GET");
+              const dom = result.dom;
+              if (dom) {
+                const truncated = dom.length > 5e4 ? dom.slice(0, 5e4) + "\n... (truncated)" : dom;
+                return { success: true, output: truncated, durationMs: Date.now() - start };
+              }
+              return { success: false, output: "", error: "DOM capture failed", durationMs: Date.now() - start };
+            }
+            case "scroll":
+              result = await apiCall("/scroll", "POST", { amount: args.amount ?? 600 });
+              return { success: !!result.ok, output: `Scrolled ${args.amount ?? 600}px`, durationMs: Date.now() - start };
+            case "scroll_up":
+              result = await apiCall("/scroll/up", "POST");
+              return { success: !!result.ok, output: "Scrolled up", durationMs: Date.now() - start };
+            case "scroll_down":
+              result = await apiCall("/scroll/down", "POST");
+              return { success: !!result.ok, output: "Scrolled down", durationMs: Date.now() - start };
+            case "back":
+              result = await apiCall("/history/back", "POST");
+              return { success: !!result.ok, output: "Navigated back", durationMs: Date.now() - start };
+            case "forward":
+              result = await apiCall("/history/forward", "POST");
+              return { success: !!result.ok, output: "Navigated forward", durationMs: Date.now() - start };
+            default:
+              return { success: false, output: "", error: `Unknown action: ${action}. Available: navigate, click, click_xy, type, screenshot, dom, scroll, scroll_up, scroll_down, back, forward, close`, durationMs: Date.now() - start };
+          }
+        } catch (err) {
+          return {
+            success: false,
+            output: "",
+            error: `Browser action failed: ${err instanceof Error ? err.message : String(err)}`,
+            durationMs: Date.now() - start
+          };
+        }
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/scheduler.js
+import { execSync as execSync16, exec as execCb } from "node:child_process";
+import { readFile as readFile9, writeFile as writeFile8, mkdir as mkdir4 } from "node:fs/promises";
+import { resolve as resolve20, join as join22 } from "node:path";
+import { randomBytes as randomBytes2 } from "node:crypto";
+function isValidCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5)
+    return false;
+  return parts.every((p) => /^[\d*,\-/]+$/.test(p));
+}
+function resolveSchedule(schedule) {
+  const lower = schedule.toLowerCase().trim();
+  if (SCHEDULE_PRESETS[lower])
+    return SCHEDULE_PRESETS[lower];
+  const inMatch = lower.match(/^in\s+(\d+)\s*(m|min|mins|minutes?|h|hr|hrs|hours?|d|days?)$/);
+  if (inMatch) {
+    const amount = parseInt(inMatch[1], 10);
+    const unit = inMatch[2].charAt(0);
+    const now = /* @__PURE__ */ new Date();
+    if (unit === "m")
+      now.setMinutes(now.getMinutes() + amount);
+    else if (unit === "h")
+      now.setHours(now.getHours() + amount);
+    else if (unit === "d")
+      now.setDate(now.getDate() + amount);
+    return `${now.getMinutes()} ${now.getHours()} ${now.getDate()} ${now.getMonth() + 1} *`;
+  }
+  const atMatch = lower.match(/^at\s+(\d{1,2}):(\d{2})$/);
+  if (atMatch) {
+    const hour = parseInt(atMatch[1], 10);
+    const minute = parseInt(atMatch[2], 10);
+    if (hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59) {
+      return `${minute} ${hour} * * *`;
+    }
+  }
+  if (isValidCron(schedule))
+    return schedule.trim();
+  return null;
+}
+function describeCron(expr) {
+  const parts = expr.split(/\s+/);
+  if (parts.length !== 5)
+    return expr;
+  const [min, hour, dom, mon, dow] = parts;
+  if (expr === "* * * * *")
+    return "every minute";
+  if (min?.startsWith("*/") && hour === "*")
+    return `every ${min.slice(2)} minutes`;
+  if (min === "0" && hour?.startsWith("*/"))
+    return `every ${hour.slice(2)} hours`;
+  if (min === "0" && hour !== "*" && dom === "*" && mon === "*" && dow === "*")
+    return `daily at ${hour}:00`;
+  if (min !== "*" && hour !== "*" && dom === "*" && mon === "*" && dow === "*")
+    return `daily at ${hour}:${min?.padStart(2, "0")}`;
+  if (dow !== "*" && dom === "*")
+    return `weekly on day ${dow} at ${hour}:${min?.padStart(2, "0")}`;
+  if (dom !== "*" && mon === "*")
+    return `monthly on day ${dom} at ${hour}:${min?.padStart(2, "0")}`;
+  return expr;
+}
+function getCurrentCrontab() {
+  try {
+    return execSync16("crontab -l 2>/dev/null", { stdio: "pipe" }).toString().split("\n");
+  } catch {
+    return [];
+  }
+}
+function writeCrontab(lines) {
+  const content = lines.join("\n") + "\n";
+  execSync16(`echo ${JSON.stringify(content)} | crontab -`, { stdio: "pipe" });
+}
+function findOaBinary() {
+  for (const cmd of ["oa", "open-agents"]) {
+    try {
+      const path = execSync16(`which ${cmd} 2>/dev/null`, { stdio: "pipe" }).toString().trim();
+      if (path)
+        return path;
+    } catch {
+    }
+  }
+  return "npx open-agents-ai";
+}
+function installCronJob(task, workingDir) {
+  const lines = getCurrentCrontab();
+  const oaBin = findOaBinary();
+  const logDir = resolve20(workingDir, ".oa", "scheduled", "logs");
+  const logFile = join22(logDir, `${task.id}.log`);
+  const cronLine = `${task.schedule} cd ${JSON.stringify(workingDir)} && ${oaBin} ${JSON.stringify(task.task)} >> ${JSON.stringify(logFile)} 2>&1 ${CRON_MARKER}${task.id}`;
+  const filtered = lines.filter((l) => !l.includes(`${CRON_MARKER}${task.id}`));
+  filtered.push(cronLine);
+  writeCrontab(filtered);
+}
+function removeCronJob(taskId) {
+  const lines = getCurrentCrontab();
+  const filtered = lines.filter((l) => !l.includes(`${CRON_MARKER}${taskId}`));
+  if (filtered.length !== lines.length) {
+    writeCrontab(filtered);
+  }
+}
+function listCronJobs() {
+  return getCurrentCrontab().filter((l) => l.includes(CRON_MARKER)).map((l) => {
+    const idMatch = l.match(new RegExp(`${CRON_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\S+)`));
+    return { id: idMatch?.[1] ?? "unknown", line: l };
+  });
+}
+async function loadStore(workingDir) {
+  const storePath = resolve20(workingDir, ".oa", "scheduled", "tasks.json");
+  try {
+    const raw = await readFile9(storePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { tasks: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function saveStore(workingDir, store) {
+  const dir = resolve20(workingDir, ".oa", "scheduled");
+  await mkdir4(dir, { recursive: true });
+  await mkdir4(join22(dir, "logs"), { recursive: true });
+  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile8(join22(dir, "tasks.json"), JSON.stringify(store, null, 2), "utf-8");
+}
+var SCHEDULE_PRESETS, CRON_MARKER, SchedulerTool;
+var init_scheduler = __esm({
+  "packages/execution/dist/tools/scheduler.js"() {
+    "use strict";
+    SCHEDULE_PRESETS = {
+      "every minute": "* * * * *",
+      "every 5 minutes": "*/5 * * * *",
+      "every 15 minutes": "*/15 * * * *",
+      "every 30 minutes": "*/30 * * * *",
+      "every hour": "0 * * * *",
+      "every 2 hours": "0 */2 * * *",
+      "every 6 hours": "0 */6 * * *",
+      "every 12 hours": "0 */12 * * *",
+      "daily": "0 9 * * *",
+      "daily morning": "0 9 * * *",
+      "daily evening": "0 18 * * *",
+      "weekly": "0 9 * * 1",
+      "monthly": "0 9 1 * *",
+      "hourly": "0 * * * *"
+    };
+    CRON_MARKER = "# OPEN-AGENTS-SCHEDULED:";
+    SchedulerTool = class {
+      name = "scheduler";
+      description = "Schedule tasks for automatic future execution using OS-level cron. Actions: 'create' a new scheduled task, 'list' all scheduled tasks, 'cancel' a task by ID, 'pause'/'resume' a task. Schedules: use presets ('daily', 'every 5 minutes', 'hourly', 'weekly'), natural language ('in 30m', 'at 14:30'), or raw cron expressions ('0 */2 * * *'). Tasks launch the agent automatically at the scheduled time.";
+      parameters = {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["create", "list", "cancel", "pause", "resume", "logs"],
+            description: "Scheduler action to perform"
+          },
+          task: {
+            type: "string",
+            description: "The task/prompt the agent should execute (for 'create')"
+          },
+          schedule: {
+            type: "string",
+            description: "When to run: preset ('daily', 'every 5 minutes'), natural ('in 30m', 'at 14:30'), or cron ('0 */2 * * *')"
+          },
+          id: {
+            type: "string",
+            description: "Task ID (for 'cancel', 'pause', 'resume', 'logs')"
+          },
+          max_runs: {
+            type: "number",
+            description: "Auto-disable after N executions (omit for unlimited)"
+          },
+          one_shot: {
+            type: "boolean",
+            description: "If true, task auto-removes after first execution"
+          }
+        },
+        required: ["action"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const start = performance.now();
+        const action = String(args["action"] ?? "list");
+        try {
+          switch (action) {
+            case "create":
+              return await this.createTask(args, start);
+            case "list":
+              return await this.listTasks(start);
+            case "cancel":
+              return await this.cancelTask(args, start);
+            case "pause":
+              return await this.toggleTask(args, false, start);
+            case "resume":
+              return await this.toggleTask(args, true, start);
+            case "logs":
+              return await this.viewLogs(args, start);
+            default:
+              return {
+                success: false,
+                output: "",
+                error: `Unknown action '${action}'. Use: create, list, cancel, pause, resume, logs`,
+                durationMs: performance.now() - start
+              };
+          }
+        } catch (err) {
+          return {
+            success: false,
+            output: "",
+            error: `Scheduler error: ${err instanceof Error ? err.message : String(err)}`,
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      async createTask(args, start) {
+        const task = String(args["task"] ?? "");
+        const schedule = String(args["schedule"] ?? "");
+        if (!task)
+          return { success: false, output: "", error: "task is required for create action", durationMs: performance.now() - start };
+        if (!schedule)
+          return { success: false, output: "", error: "schedule is required for create action", durationMs: performance.now() - start };
+        const cronExpr = resolveSchedule(schedule);
+        if (!cronExpr) {
+          return {
+            success: false,
+            output: "",
+            error: `Cannot parse schedule '${schedule}'. Use presets (daily, hourly, every 5 minutes), natural (in 30m, at 14:30), or cron (0 */2 * * *). Available presets: ${Object.keys(SCHEDULE_PRESETS).join(", ")}`,
+            durationMs: performance.now() - start
+          };
+        }
+        const id = `sched-${randomBytes2(4).toString("hex")}`;
+        const oneShot = Boolean(args["one_shot"]);
+        const maxRuns = typeof args["max_runs"] === "number" ? args["max_runs"] : void 0;
+        const newTask = {
+          id,
+          task,
+          schedule: cronExpr,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          nextRunDescription: describeCron(cronExpr),
+          enabled: true,
+          runCount: 0,
+          maxRuns,
+          oneShot: oneShot || void 0
+        };
+        const store = await loadStore(this.workingDir);
+        store.tasks.push(newTask);
+        await saveStore(this.workingDir, store);
+        installCronJob(newTask, this.workingDir);
+        return {
+          success: true,
+          output: [
+            `Scheduled task created:`,
+            `  ID: ${id}`,
+            `  Task: ${task}`,
+            `  Schedule: ${describeCron(cronExpr)} (${cronExpr})`,
+            oneShot ? `  Mode: one-shot (auto-removes after first run)` : "",
+            maxRuns ? `  Max runs: ${maxRuns}` : "",
+            `  Status: enabled`,
+            ``,
+            `The agent will launch automatically at the scheduled time.`,
+            `Use scheduler(action='logs', id='${id}') to check execution history.`
+          ].filter(Boolean).join("\n"),
+          durationMs: performance.now() - start
+        };
+      }
+      async listTasks(start) {
+        const store = await loadStore(this.workingDir);
+        const cronJobs = listCronJobs();
+        if (store.tasks.length === 0) {
+          return {
+            success: true,
+            output: "No scheduled tasks. Use scheduler(action='create', task='...', schedule='daily') to create one.",
+            durationMs: performance.now() - start
+          };
+        }
+        const lines = [`Scheduled Tasks (${store.tasks.length}):
+`];
+        for (const t of store.tasks) {
+          const status = t.enabled ? "enabled" : "PAUSED";
+          const cronInstalled = cronJobs.some((j) => j.id === t.id);
+          const cronStatus = cronInstalled ? "" : " [cron not installed]";
+          lines.push(`  [${t.id}] ${status}${cronStatus}`);
+          lines.push(`    Task: ${t.task.slice(0, 100)}${t.task.length > 100 ? "..." : ""}`);
+          lines.push(`    Schedule: ${t.nextRunDescription} (${t.schedule})`);
+          lines.push(`    Runs: ${t.runCount}${t.maxRuns ? `/${t.maxRuns}` : ""}${t.oneShot ? " (one-shot)" : ""}`);
+          if (t.lastRun)
+            lines.push(`    Last run: ${t.lastRun}`);
+          lines.push("");
+        }
+        return {
+          success: true,
+          output: lines.join("\n"),
+          durationMs: performance.now() - start
+        };
+      }
+      async cancelTask(args, start) {
+        const id = String(args["id"] ?? "");
+        if (!id)
+          return { success: false, output: "", error: "id is required for cancel action", durationMs: performance.now() - start };
+        const store = await loadStore(this.workingDir);
+        const idx = store.tasks.findIndex((t) => t.id === id);
+        if (idx === -1)
+          return { success: false, output: "", error: `No task found with ID '${id}'`, durationMs: performance.now() - start };
+        const removed = store.tasks.splice(idx, 1)[0];
+        await saveStore(this.workingDir, store);
+        removeCronJob(id);
+        return {
+          success: true,
+          output: `Cancelled and removed scheduled task '${id}': ${removed.task.slice(0, 80)}`,
+          durationMs: performance.now() - start
+        };
+      }
+      async toggleTask(args, enable, start) {
+        const id = String(args["id"] ?? "");
+        if (!id)
+          return { success: false, output: "", error: "id is required", durationMs: performance.now() - start };
+        const store = await loadStore(this.workingDir);
+        const task = store.tasks.find((t) => t.id === id);
+        if (!task)
+          return { success: false, output: "", error: `No task found with ID '${id}'`, durationMs: performance.now() - start };
+        task.enabled = enable;
+        await saveStore(this.workingDir, store);
+        if (enable) {
+          installCronJob(task, this.workingDir);
+        } else {
+          removeCronJob(id);
+        }
+        return {
+          success: true,
+          output: `Task '${id}' ${enable ? "resumed" : "paused"}: ${task.task.slice(0, 80)}`,
+          durationMs: performance.now() - start
+        };
+      }
+      async viewLogs(args, start) {
+        const id = String(args["id"] ?? "");
+        if (!id)
+          return { success: false, output: "", error: "id is required for logs action", durationMs: performance.now() - start };
+        const logFile = resolve20(this.workingDir, ".oa", "scheduled", "logs", `${id}.log`);
+        try {
+          const raw = await readFile9(logFile, "utf-8");
+          const truncated = raw.length > 1e4 ? "...(truncated)\n" + raw.slice(-1e4) : raw;
+          return { success: true, output: `Logs for ${id}:
+${truncated}`, durationMs: performance.now() - start };
+        } catch {
+          return { success: true, output: `No logs yet for task '${id}'.`, durationMs: performance.now() - start };
+        }
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/reminder.js
+import { readFile as readFile10, writeFile as writeFile9, mkdir as mkdir5 } from "node:fs/promises";
+import { resolve as resolve21, join as join23 } from "node:path";
+import { randomBytes as randomBytes3 } from "node:crypto";
+function parseDueTime(due) {
+  const lower = due.toLowerCase().trim();
+  const now = /* @__PURE__ */ new Date();
+  const inMatch = lower.match(/^in\s+(\d+)\s*(m|min|mins|minutes?|h|hr|hrs|hours?|d|days?|w|weeks?)$/);
+  if (inMatch) {
+    const amount = parseInt(inMatch[1], 10);
+    const unit = inMatch[2].charAt(0);
+    const target = new Date(now);
+    if (unit === "m")
+      target.setMinutes(target.getMinutes() + amount);
+    else if (unit === "h")
+      target.setHours(target.getHours() + amount);
+    else if (unit === "d")
+      target.setDate(target.getDate() + amount);
+    else if (unit === "w")
+      target.setDate(target.getDate() + amount * 7);
+    return { isoDate: target.toISOString(), description: `in ${amount}${unit}` };
+  }
+  if (lower === "tomorrow") {
+    const target = new Date(now);
+    target.setDate(target.getDate() + 1);
+    target.setHours(9, 0, 0, 0);
+    return { isoDate: target.toISOString(), description: "tomorrow morning" };
+  }
+  if (lower === "next week") {
+    const target = new Date(now);
+    target.setDate(target.getDate() + 7);
+    target.setHours(9, 0, 0, 0);
+    return { isoDate: target.toISOString(), description: "next week" };
+  }
+  const todayMatch = lower.match(/^(?:today\s+)?at\s+(\d{1,2}):(\d{2})$/);
+  if (todayMatch) {
+    const target = new Date(now);
+    target.setHours(parseInt(todayMatch[1], 10), parseInt(todayMatch[2], 10), 0, 0);
+    if (target <= now)
+      target.setDate(target.getDate() + 1);
+    return { isoDate: target.toISOString(), description: `at ${todayMatch[1]}:${todayMatch[2]}` };
+  }
+  if (lower === "now" || lower === "next startup" || lower === "startup") {
+    return { isoDate: now.toISOString(), description: "next startup" };
+  }
+  const parsed = new Date(due);
+  if (!isNaN(parsed.getTime())) {
+    return { isoDate: parsed.toISOString(), description: parsed.toLocaleDateString() };
+  }
+  return null;
+}
+async function getStorePath(workingDir) {
+  const dir = resolve21(workingDir, ".oa", "scheduled");
+  await mkdir5(dir, { recursive: true });
+  return join23(dir, STORE_FILE);
+}
+async function loadReminderStore(workingDir) {
+  const storePath = await getStorePath(workingDir);
+  try {
+    const raw = await readFile10(storePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { reminders: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function saveReminderStore(workingDir, store) {
+  const storePath = await getStorePath(workingDir);
+  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile9(storePath, JSON.stringify(store, null, 2), "utf-8");
+}
+async function getDueReminders(workingDir) {
+  const store = await loadReminderStore(workingDir);
+  const now = /* @__PURE__ */ new Date();
+  return store.reminders.filter((r) => {
+    if (r.status !== "pending")
+      return false;
+    if (!r.dueAt)
+      return true;
+    return new Date(r.dueAt) <= now;
+  });
+}
+async function markRemindersSeen(workingDir, ids) {
+  const store = await loadReminderStore(workingDir);
+  const idSet = new Set(ids);
+  for (const r of store.reminders) {
+    if (idSet.has(r.id) && r.status === "pending") {
+      r.status = "seen";
+      r.seenAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  await saveReminderStore(workingDir, store);
+}
+var STORE_FILE, ReminderTool;
+var init_reminder = __esm({
+  "packages/execution/dist/tools/reminder.js"() {
+    "use strict";
+    STORE_FILE = "reminders.json";
+    ReminderTool = class {
+      name = "reminder";
+      description = "Set reminders that surface at future agent startups. Leave instructions for your future self across sessions. Actions: 'set' a new reminder, 'list' all reminders, 'complete' or 'dismiss' a reminder, 'snooze' to postpone. Reminders appear automatically when the agent starts and can have due dates, priority levels, and tags for filtering.";
+      parameters = {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["set", "list", "complete", "dismiss", "snooze"],
+            description: "Reminder action to perform"
+          },
+          message: {
+            type: "string",
+            description: "The reminder message (for 'set')"
+          },
+          due: {
+            type: "string",
+            description: "When the reminder should surface: 'in 30m', 'tomorrow', 'at 14:30', 'next startup', 'in 2d' (for 'set' and 'snooze')"
+          },
+          priority: {
+            type: "string",
+            enum: ["low", "normal", "high", "critical"],
+            description: "Priority level (default: normal)"
+          },
+          tags: {
+            type: "string",
+            description: "Comma-separated tags for categorization (e.g. 'deploy,auth,urgent')"
+          },
+          context: {
+            type: "string",
+            description: "Additional context: file paths, task details, debugging notes"
+          },
+          id: {
+            type: "string",
+            description: "Reminder ID (for 'complete', 'dismiss', 'snooze')"
+          },
+          filter: {
+            type: "string",
+            description: "Filter by status: 'pending', 'seen', 'all' (for 'list', default: 'pending')"
+          }
+        },
+        required: ["action"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const start = performance.now();
+        const action = String(args["action"] ?? "list");
+        try {
+          switch (action) {
+            case "set":
+              return await this.setReminder(args, start);
+            case "list":
+              return await this.listReminders(args, start);
+            case "complete":
+              return await this.updateStatus(args, "completed", start);
+            case "dismiss":
+              return await this.updateStatus(args, "dismissed", start);
+            case "snooze":
+              return await this.snoozeReminder(args, start);
+            default:
+              return {
+                success: false,
+                output: "",
+                error: `Unknown action '${action}'. Use: set, list, complete, dismiss, snooze`,
+                durationMs: performance.now() - start
+              };
+          }
+        } catch (err) {
+          return {
+            success: false,
+            output: "",
+            error: `Reminder error: ${err instanceof Error ? err.message : String(err)}`,
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      async setReminder(args, start) {
+        const message = String(args["message"] ?? "");
+        if (!message)
+          return { success: false, output: "", error: "message is required for set action", durationMs: performance.now() - start };
+        const priority = args["priority"] ?? "normal";
+        const tagsStr = args["tags"] ?? "";
+        const tags = tagsStr ? tagsStr.split(",").map((t) => t.trim()).filter(Boolean) : [];
+        const context = args["context"] ?? void 0;
+        const dueStr = args["due"] ?? "";
+        let dueAt;
+        let dueDescription;
+        if (dueStr) {
+          const parsed = parseDueTime(dueStr);
+          if (!parsed) {
+            return {
+              success: false,
+              output: "",
+              error: `Cannot parse due time '${dueStr}'. Try: 'in 30m', 'tomorrow', 'at 14:30', 'next startup', 'in 2d'`,
+              durationMs: performance.now() - start
+            };
+          }
+          dueAt = parsed.isoDate;
+          dueDescription = parsed.description;
+        }
+        const id = `rem-${randomBytes3(4).toString("hex")}`;
+        const entry = {
+          id,
+          message,
+          priority,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          dueAt,
+          dueDescription,
+          tags,
+          status: "pending",
+          context,
+          source: "agent"
+        };
+        const store = await loadReminderStore(this.workingDir);
+        store.reminders.push(entry);
+        await saveReminderStore(this.workingDir, store);
+        return {
+          success: true,
+          output: [
+            `Reminder set:`,
+            `  ID: ${id}`,
+            `  Message: ${message}`,
+            `  Priority: ${priority}`,
+            dueDescription ? `  Due: ${dueDescription}` : `  Due: next startup`,
+            tags.length > 0 ? `  Tags: ${tags.join(", ")}` : "",
+            context ? `  Context: ${context.slice(0, 100)}` : "",
+            ``,
+            `This reminder will surface when the agent next starts${dueDescription ? ` (after ${dueDescription})` : ""}.`
+          ].filter(Boolean).join("\n"),
+          durationMs: performance.now() - start
+        };
+      }
+      async listReminders(args, start) {
+        const store = await loadReminderStore(this.workingDir);
+        const filter = String(args["filter"] ?? "pending");
+        let filtered = store.reminders;
+        if (filter === "pending")
+          filtered = filtered.filter((r) => r.status === "pending" || r.status === "seen");
+        else if (filter !== "all")
+          filtered = filtered.filter((r) => r.status === filter);
+        if (filtered.length === 0) {
+          return {
+            success: true,
+            output: filter === "all" ? "No reminders set. Use reminder(action='set', message='...') to create one." : `No ${filter} reminders. Use reminder(action='list', filter='all') to see all.`,
+            durationMs: performance.now() - start
+          };
+        }
+        const priorityOrder = { critical: 0, high: 1, normal: 2, low: 3 };
+        filtered.sort((a, b) => (priorityOrder[a.priority] ?? 2) - (priorityOrder[b.priority] ?? 2));
+        const lines = [`Reminders (${filtered.length} ${filter}):
+`];
+        for (const r of filtered) {
+          const priorityIcon = r.priority === "critical" ? "[!!!]" : r.priority === "high" ? "[!!]" : r.priority === "low" ? "[.]" : "[*]";
+          const statusLabel = r.status === "seen" ? " (seen)" : r.status === "completed" ? " (done)" : r.status === "dismissed" ? " (dismissed)" : "";
+          lines.push(`  ${priorityIcon} [${r.id}]${statusLabel}`);
+          lines.push(`    ${r.message}`);
+          if (r.dueDescription)
+            lines.push(`    Due: ${r.dueDescription}`);
+          if (r.tags.length > 0)
+            lines.push(`    Tags: ${r.tags.join(", ")}`);
+          if (r.context)
+            lines.push(`    Context: ${r.context.slice(0, 80)}${r.context.length > 80 ? "..." : ""}`);
+          lines.push("");
+        }
+        return {
+          success: true,
+          output: lines.join("\n"),
+          durationMs: performance.now() - start
+        };
+      }
+      async updateStatus(args, status, start) {
+        const id = String(args["id"] ?? "");
+        if (!id)
+          return { success: false, output: "", error: "id is required", durationMs: performance.now() - start };
+        const store = await loadReminderStore(this.workingDir);
+        const reminder = store.reminders.find((r) => r.id === id);
+        if (!reminder)
+          return { success: false, output: "", error: `No reminder found with ID '${id}'`, durationMs: performance.now() - start };
+        reminder.status = status;
+        await saveReminderStore(this.workingDir, store);
+        return {
+          success: true,
+          output: `Reminder '${id}' marked as ${status}: ${reminder.message.slice(0, 80)}`,
+          durationMs: performance.now() - start
+        };
+      }
+      async snoozeReminder(args, start) {
+        const id = String(args["id"] ?? "");
+        const due = String(args["due"] ?? "in 1h");
+        if (!id)
+          return { success: false, output: "", error: "id is required for snooze", durationMs: performance.now() - start };
+        const parsed = parseDueTime(due);
+        if (!parsed)
+          return { success: false, output: "", error: `Cannot parse due time '${due}'`, durationMs: performance.now() - start };
+        const store = await loadReminderStore(this.workingDir);
+        const reminder = store.reminders.find((r) => r.id === id);
+        if (!reminder)
+          return { success: false, output: "", error: `No reminder found with ID '${id}'`, durationMs: performance.now() - start };
+        reminder.status = "pending";
+        reminder.dueAt = parsed.isoDate;
+        reminder.dueDescription = parsed.description;
+        reminder.seenAt = void 0;
+        await saveReminderStore(this.workingDir, store);
+        return {
+          success: true,
+          output: `Reminder '${id}' snoozed until ${parsed.description}: ${reminder.message.slice(0, 80)}`,
+          durationMs: performance.now() - start
+        };
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/agenda.js
+import { readFile as readFile11, writeFile as writeFile10, mkdir as mkdir6 } from "node:fs/promises";
+import { resolve as resolve22, join as join24 } from "node:path";
+import { randomBytes as randomBytes4 } from "node:crypto";
+async function loadAttentionStore(workingDir) {
+  const storePath = resolve22(workingDir, ".oa", "scheduled", "attention.json");
+  try {
+    const raw = await readFile11(storePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { items: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function saveAttentionStore(workingDir, store) {
+  const dir = resolve22(workingDir, ".oa", "scheduled");
+  await mkdir6(dir, { recursive: true });
+  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile10(join24(dir, "attention.json"), JSON.stringify(store, null, 2), "utf-8");
+}
+async function getActiveAttentionItems(workingDir) {
+  const store = await loadAttentionStore(workingDir);
+  const now = /* @__PURE__ */ new Date();
+  let changed = false;
+  for (const item of store.items) {
+    if (item.status === "active" && item.expiresAt && new Date(item.expiresAt) <= now) {
+      item.status = "expired";
+      changed = true;
+    }
+  }
+  if (changed)
+    await saveAttentionStore(workingDir, store);
+  return store.items.filter((i) => i.status === "active");
+}
+var AgendaTool;
+var init_agenda = __esm({
+  "packages/execution/dist/tools/agenda.js"() {
+    "use strict";
+    init_reminder();
+    AgendaTool = class {
+      name = "agenda";
+      description = "View and manage the agent's temporal awareness: pending reminders, scheduled tasks, and attention items. Actions: 'view' the full agenda (default), 'flag' an item for attention, 'resolve' an attention item, 'startup_brief' to see what surfaces at next startup. Categories: followup (check back on something), review (code/PR review needed), monitor (watch for changes), investigate (dig deeper), decision (needs a call).";
+      parameters = {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["view", "flag", "resolve", "startup_brief"],
+            description: "Agenda action (default: view)"
+          },
+          title: {
+            type: "string",
+            description: "Title for the attention item (for 'flag')"
+          },
+          description: {
+            type: "string",
+            description: "Detailed description (for 'flag')"
+          },
+          category: {
+            type: "string",
+            enum: ["followup", "review", "monitor", "investigate", "decision"],
+            description: "Category of attention item (for 'flag')"
+          },
+          priority: {
+            type: "string",
+            enum: ["low", "normal", "high", "critical"],
+            description: "Priority level (for 'flag', default: normal)"
+          },
+          expires_in: {
+            type: "string",
+            description: "Auto-dismiss after duration: 'in 1h', 'in 7d', 'in 30d' (for 'flag')"
+          },
+          related_files: {
+            type: "string",
+            description: "Comma-separated related file paths (for 'flag')"
+          },
+          notes: {
+            type: "string",
+            description: "Working notes or context (for 'flag')"
+          },
+          id: {
+            type: "string",
+            description: "Item ID (for 'resolve')"
+          }
+        },
+        required: []
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const start = performance.now();
+        const action = String(args["action"] ?? "view");
+        try {
+          switch (action) {
+            case "view":
+              return await this.viewAgenda(start);
+            case "flag":
+              return await this.flagAttention(args, start);
+            case "resolve":
+              return await this.resolveItem(args, start);
+            case "startup_brief":
+              return await this.startupBrief(start);
+            default:
+              return {
+                success: false,
+                output: "",
+                error: `Unknown action '${action}'. Use: view, flag, resolve, startup_brief`,
+                durationMs: performance.now() - start
+              };
+          }
+        } catch (err) {
+          return {
+            success: false,
+            output: "",
+            error: `Agenda error: ${err instanceof Error ? err.message : String(err)}`,
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      async viewAgenda(start) {
+        const [dueReminders, activeAttention, schedStore] = await Promise.all([
+          getDueReminders(this.workingDir),
+          getActiveAttentionItems(this.workingDir),
+          this.loadScheduleStore()
+        ]);
+        const sections = [];
+        if (dueReminders.length > 0) {
+          sections.push(`REMINDERS DUE (${dueReminders.length}):`);
+          for (const r of dueReminders) {
+            const icon = r.priority === "critical" ? "[!!!]" : r.priority === "high" ? "[!!]" : "[*]";
+            sections.push(`  ${icon} [${r.id}] ${r.message}`);
+            if (r.context)
+              sections.push(`    Context: ${r.context.slice(0, 80)}`);
+          }
+          sections.push("");
+        }
+        if (activeAttention.length > 0) {
+          sections.push(`ATTENTION ITEMS (${activeAttention.length}):`);
+          const priorityOrder = { critical: 0, high: 1, normal: 2, low: 3 };
+          activeAttention.sort((a, b) => (priorityOrder[a.priority] ?? 2) - (priorityOrder[b.priority] ?? 2));
+          for (const item of activeAttention) {
+            const icon = item.priority === "critical" ? "[!!!]" : item.priority === "high" ? "[!!]" : "[*]";
+            sections.push(`  ${icon} [${item.id}] (${item.category}) ${item.title}`);
+            if (item.description)
+              sections.push(`    ${item.description.slice(0, 100)}`);
+            if (item.relatedFiles?.length)
+              sections.push(`    Files: ${item.relatedFiles.join(", ")}`);
+            if (item.expiresAt)
+              sections.push(`    Expires: ${new Date(item.expiresAt).toLocaleString()}`);
+          }
+          sections.push("");
+        }
+        const enabledTasks = schedStore.filter((t) => t.enabled);
+        if (enabledTasks.length > 0) {
+          sections.push(`SCHEDULED TASKS (${enabledTasks.length} active):`);
+          for (const t of enabledTasks) {
+            sections.push(`  [${t.id}] ${t.nextRunDescription}: ${t.task.slice(0, 80)}`);
+          }
+          sections.push("");
+        }
+        if (sections.length === 0) {
+          return {
+            success: true,
+            output: "Agenda is clear. No pending reminders, attention items, or scheduled tasks.",
+            durationMs: performance.now() - start
+          };
+        }
+        return {
+          success: true,
+          output: `AGENT AGENDA
+${"\u2500".repeat(50)}
+
+${sections.join("\n")}`,
+          durationMs: performance.now() - start
+        };
+      }
+      async flagAttention(args, start) {
+        const title = String(args["title"] ?? "");
+        if (!title)
+          return { success: false, output: "", error: "title is required for flag action", durationMs: performance.now() - start };
+        const description = String(args["description"] ?? "");
+        const category = args["category"] ?? "followup";
+        const priority = args["priority"] ?? "normal";
+        const notes = args["notes"] ?? void 0;
+        const relatedFilesStr = args["related_files"] ?? "";
+        const relatedFiles = relatedFilesStr ? relatedFilesStr.split(",").map((f) => f.trim()).filter(Boolean) : void 0;
+        let expiresAt;
+        const expiresIn = args["expires_in"] ?? "";
+        if (expiresIn) {
+          const match = expiresIn.match(/^(?:in\s+)?(\d+)\s*(m|h|d|w)/);
+          if (match) {
+            const target = /* @__PURE__ */ new Date();
+            const amount = parseInt(match[1], 10);
+            const unit = match[2];
+            if (unit === "m")
+              target.setMinutes(target.getMinutes() + amount);
+            else if (unit === "h")
+              target.setHours(target.getHours() + amount);
+            else if (unit === "d")
+              target.setDate(target.getDate() + amount);
+            else if (unit === "w")
+              target.setDate(target.getDate() + amount * 7);
+            expiresAt = target.toISOString();
+          }
+        }
+        const id = `attn-${randomBytes4(4).toString("hex")}`;
+        const item = {
+          id,
+          title,
+          description,
+          category,
+          priority,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          expiresAt,
+          relatedFiles,
+          status: "active",
+          notes
+        };
+        const store = await loadAttentionStore(this.workingDir);
+        store.items.push(item);
+        await saveAttentionStore(this.workingDir, store);
+        return {
+          success: true,
+          output: [
+            `Attention item flagged:`,
+            `  ID: ${id}`,
+            `  Title: ${title}`,
+            `  Category: ${category}`,
+            `  Priority: ${priority}`,
+            expiresAt ? `  Expires: ${new Date(expiresAt).toLocaleString()}` : "",
+            relatedFiles ? `  Files: ${relatedFiles.join(", ")}` : "",
+            ``,
+            `This item will appear in the agent's agenda until resolved or expired.`
+          ].filter(Boolean).join("\n"),
+          durationMs: performance.now() - start
+        };
+      }
+      async resolveItem(args, start) {
+        const id = String(args["id"] ?? "");
+        if (!id)
+          return { success: false, output: "", error: "id is required for resolve", durationMs: performance.now() - start };
+        const store = await loadAttentionStore(this.workingDir);
+        const item = store.items.find((i) => i.id === id);
+        if (!item)
+          return { success: false, output: "", error: `No attention item found with ID '${id}'`, durationMs: performance.now() - start };
+        item.status = "resolved";
+        item.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await saveAttentionStore(this.workingDir, store);
+        return {
+          success: true,
+          output: `Attention item '${id}' resolved: ${item.title}`,
+          durationMs: performance.now() - start
+        };
+      }
+      async startupBrief(start) {
+        const [dueReminders, activeAttention] = await Promise.all([
+          getDueReminders(this.workingDir),
+          getActiveAttentionItems(this.workingDir)
+        ]);
+        const criticalReminders = dueReminders.filter((r) => r.priority === "critical" || r.priority === "high");
+        const criticalAttention = activeAttention.filter((a) => a.priority === "critical" || a.priority === "high");
+        const lines = [];
+        if (criticalReminders.length > 0 || criticalAttention.length > 0) {
+          lines.push(`URGENT ITEMS REQUIRING IMMEDIATE ATTENTION:
+`);
+          for (const r of criticalReminders) {
+            lines.push(`  [REMINDER] ${r.message}`);
+            if (r.context)
+              lines.push(`    Context: ${r.context}`);
+          }
+          for (const a of criticalAttention) {
+            lines.push(`  [${a.category.toUpperCase()}] ${a.title}: ${a.description}`);
+            if (a.relatedFiles?.length)
+              lines.push(`    Files: ${a.relatedFiles.join(", ")}`);
+          }
+          lines.push("");
+        }
+        const normalReminders = dueReminders.filter((r) => r.priority !== "critical" && r.priority !== "high");
+        const normalAttention = activeAttention.filter((a) => a.priority !== "critical" && a.priority !== "high");
+        if (normalReminders.length > 0) {
+          lines.push(`Pending reminders: ${normalReminders.length}`);
+          for (const r of normalReminders.slice(0, 5)) {
+            lines.push(`  - ${r.message}`);
+          }
+          if (normalReminders.length > 5)
+            lines.push(`  ... and ${normalReminders.length - 5} more`);
+          lines.push("");
+        }
+        if (normalAttention.length > 0) {
+          lines.push(`Active attention items: ${normalAttention.length}`);
+          for (const a of normalAttention.slice(0, 5)) {
+            lines.push(`  - (${a.category}) ${a.title}`);
+          }
+          if (normalAttention.length > 5)
+            lines.push(`  ... and ${normalAttention.length - 5} more`);
+        }
+        if (lines.length === 0) {
+          return {
+            success: true,
+            output: "No pending items for this startup. Agenda is clear.",
+            durationMs: performance.now() - start
+          };
+        }
+        return {
+          success: true,
+          output: lines.join("\n"),
+          durationMs: performance.now() - start
+        };
+      }
+      async loadScheduleStore() {
+        try {
+          const storePath = resolve22(this.workingDir, ".oa", "scheduled", "tasks.json");
+          const raw = await readFile11(storePath, "utf-8");
+          const store = JSON.parse(raw);
+          return store.tasks ?? [];
+        } catch {
+          return [];
+        }
+      }
+    };
+  }
+});
+
 // packages/execution/dist/shellRunner.js
 var init_shellRunner = __esm({
   "packages/execution/dist/shellRunner.js"() {
@@ -8765,6 +10011,10 @@ var init_dist2 = __esm({
     init_ocr_pdf();
     init_pdf_to_text();
     init_ocr_image_advanced();
+    init_browser_action();
+    init_scheduler();
+    init_reminder();
+    init_agenda();
     init_system_deps();
     init_shellRunner();
     init_gitWorktree();
@@ -9880,8 +11130,8 @@ var init_code_retriever = __esm({
         });
       }
       async getFileContent(filePath, startLine, endLine) {
-        const { readFile: readFile12 } = await import("node:fs/promises");
-        const content = await readFile12(filePath, "utf-8");
+        const { readFile: readFile15 } = await import("node:fs/promises");
+        const content = await readFile15(filePath, "utf-8");
         if (startLine === void 0)
           return content;
         const lines = content.split("\n");
@@ -9896,8 +11146,8 @@ var init_code_retriever = __esm({
 // packages/retrieval/dist/lexicalSearch.js
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { readFile as readFile9, readdir as readdir3, stat as stat3 } from "node:fs/promises";
-import { join as join21, extname as extname7 } from "node:path";
+import { readFile as readFile12, readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import { join as join25, extname as extname7 } from "node:path";
 async function searchByPath(pathPattern, options) {
   const allFiles = await collectFiles(options.rootDir, options.includeGlobs ?? DEFAULT_INCLUDE_GLOBS, options.excludeGlobs ?? DEFAULT_EXCLUDE_GLOBS);
   const pattern = options.caseInsensitive ? pathPattern.toLowerCase() : pathPattern;
@@ -10002,7 +11252,7 @@ async function searchWithNodeFallback(pattern, kind, options) {
     if (results.length >= maxMatches)
       break;
     try {
-      const content = await readFile9(filePath, "utf-8");
+      const content = await readFile12(filePath, "utf-8");
       const contentLines = content.split("\n");
       for (let i = 0; i < contentLines.length; i++) {
         if (results.length >= maxMatches)
@@ -10039,7 +11289,7 @@ async function walkForFiles(rootDir, dir, excludeGlobs, results) {
       continue;
     if (excludeGlobs.some((g) => entry.name === g || matchesGlob(entry.name, g)))
       continue;
-    const absPath = join21(dir, entry.name);
+    const absPath = join25(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForFiles(rootDir, absPath, excludeGlobs, results);
     } else if (entry.isFile()) {
@@ -10345,8 +11595,8 @@ var init_graphExpand = __esm({
 });
 
 // packages/retrieval/dist/snippetPacker.js
-import { readFile as readFile10 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { readFile as readFile13 } from "node:fs/promises";
+import { join as join26 } from "node:path";
 async function packSnippets(requests, opts = {}) {
   const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
   const contextLines = opts.contextLines ?? DEFAULT_CONTEXT_LINES;
@@ -10372,10 +11622,10 @@ async function packSnippets(requests, opts = {}) {
   return { packed, dropped, totalTokens };
 }
 async function extractSnippet(req, repoRoot, contextLines = DEFAULT_CONTEXT_LINES) {
-  const absPath = req.filePath.startsWith("/") ? req.filePath : join22(repoRoot, req.filePath);
+  const absPath = req.filePath.startsWith("/") ? req.filePath : join26(repoRoot, req.filePath);
   let content;
   try {
-    content = await readFile10(absPath, "utf-8");
+    content = await readFile13(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -12079,8 +13329,8 @@ Rules:
       async waitIfPaused() {
         if (!this._paused)
           return true;
-        await new Promise((resolve23) => {
-          this._pauseResolve = resolve23;
+        await new Promise((resolve26) => {
+          this._pauseResolve = resolve26;
         });
         return !this.aborted;
       }
@@ -12298,7 +13548,8 @@ Integrate this guidance into your current approach. Continue working on the task
               "task_output",
               "image_read",
               "screenshot",
-              "ocr"
+              "ocr",
+              "browser_action"
             ]);
             const executeSingle = async (tc) => {
               if (this.aborted)
@@ -12659,14 +13910,14 @@ ${result.output}`;
       waitForSudoPassword(timeoutMs = 12e4) {
         if (this._sudoPassword)
           return Promise.resolve(this._sudoPassword);
-        return new Promise((resolve23) => {
+        return new Promise((resolve26) => {
           const timer = setTimeout(() => {
             this._sudoResolve = null;
-            resolve23(null);
+            resolve26(null);
           }, timeoutMs);
           this._sudoResolve = (pw) => {
             clearTimeout(timer);
-            resolve23(pw);
+            resolve26(pw);
           };
         });
       }
@@ -12789,8 +14040,8 @@ ${marker}` : marker);
           return;
         try {
           const { mkdirSync: mkdirSync13, writeFileSync: writeFileSync12 } = __require("node:fs");
-          const { join: join37 } = __require("node:path");
-          const sessionDir = join37(this._workingDirectory, ".oa", "session", this._sessionId);
+          const { join: join41 } = __require("node:path");
+          const sessionDir = join41(this._workingDirectory, ".oa", "session", this._sessionId);
           mkdirSync13(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12803,7 +14054,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync12(join37(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync12(join41(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -13759,6 +15010,7 @@ ${transcript}`
           temperature: request.temperature,
           max_tokens: request.maxTokens,
           stream: true,
+          stream_options: { include_usage: true },
           think: true
         };
         const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, {
@@ -14340,11 +15592,11 @@ var init_dist5 = __esm({
 });
 
 // packages/cli/dist/tui/listen.js
-import { spawn as spawn7, execSync as execSync15 } from "node:child_process";
-import { existsSync as existsSync18, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readdirSync as readdirSync6 } from "node:fs";
-import { join as join23, dirname as dirname8 } from "node:path";
+import { spawn as spawn8, execSync as execSync17 } from "node:child_process";
+import { existsSync as existsSync19, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readdirSync as readdirSync6 } from "node:fs";
+import { join as join27, dirname as dirname9 } from "node:path";
 import { homedir as homedir8 } from "node:os";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { EventEmitter } from "node:events";
 import { createInterface as createInterface2 } from "node:readline";
 function isAudioPath(path) {
@@ -14362,7 +15614,7 @@ function findMicCaptureCommand() {
   const platform4 = process.platform;
   if (platform4 === "linux") {
     try {
-      execSync15("which arecord", { stdio: "pipe" });
+      execSync17("which arecord", { stdio: "pipe" });
       return {
         cmd: "arecord",
         args: ["-f", "S16_LE", "-r", "16000", "-c", "1", "-t", "raw", "-q", "-"]
@@ -14372,7 +15624,7 @@ function findMicCaptureCommand() {
   }
   if (platform4 === "darwin") {
     try {
-      execSync15("which sox", { stdio: "pipe" });
+      execSync17("which sox", { stdio: "pipe" });
       return {
         cmd: "sox",
         args: ["-d", "-t", "raw", "-r", "16000", "-c", "1", "-b", "16", "-e", "signed-integer", "-"]
@@ -14381,7 +15633,7 @@ function findMicCaptureCommand() {
     }
   }
   try {
-    execSync15("which ffmpeg", { stdio: "pipe" });
+    execSync17("which ffmpeg", { stdio: "pipe" });
     if (platform4 === "linux") {
       return {
         cmd: "ffmpeg",
@@ -14426,41 +15678,41 @@ function findMicCaptureCommand() {
   return null;
 }
 function findLiveWhisperScript() {
-  const thisDir = dirname8(fileURLToPath5(import.meta.url));
+  const thisDir = dirname9(fileURLToPath6(import.meta.url));
   const candidates = [
-    join23(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
-    join23(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
-    join23(thisDir, "../../execution/scripts/live-whisper.py"),
+    join27(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
+    join27(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
+    join27(thisDir, "../../execution/scripts/live-whisper.py"),
     // npm install layout — scripts bundled alongside dist
-    join23(thisDir, "../scripts/live-whisper.py"),
-    join23(thisDir, "../../scripts/live-whisper.py")
+    join27(thisDir, "../scripts/live-whisper.py"),
+    join27(thisDir, "../../scripts/live-whisper.py")
   ];
   for (const p of candidates) {
-    if (existsSync18(p))
+    if (existsSync19(p))
       return p;
   }
   try {
-    const globalRoot = execSync15("npm root -g", {
+    const globalRoot = execSync17("npm root -g", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const candidates2 = [
-      join23(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
-      join23(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
+      join27(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
+      join27(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
     ];
     for (const p of candidates2) {
-      if (existsSync18(p))
+      if (existsSync19(p))
         return p;
     }
   } catch {
   }
-  const nvmBase = join23(homedir8(), ".nvm", "versions", "node");
-  if (existsSync18(nvmBase)) {
+  const nvmBase = join27(homedir8(), ".nvm", "versions", "node");
+  if (existsSync19(nvmBase)) {
     try {
       for (const ver of readdirSync6(nvmBase)) {
-        const p = join23(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
-        if (existsSync18(p))
+        const p = join27(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
+        if (existsSync19(p))
           return p;
       }
     } catch {
@@ -14473,21 +15725,21 @@ function ensureTranscribeCliBackground() {
     return;
   _bgInstallPromise = (async () => {
     try {
-      const globalRoot = execSync15("npm root -g", {
+      const globalRoot = execSync17("npm root -g", {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      if (existsSync18(join23(globalRoot, "transcribe-cli", "dist", "index.js"))) {
+      if (existsSync19(join27(globalRoot, "transcribe-cli", "dist", "index.js"))) {
         return true;
       }
     } catch {
     }
     try {
       const { exec } = await import("node:child_process");
-      return new Promise((resolve23) => {
+      return new Promise((resolve26) => {
         exec("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
-          resolve23(!err);
+          resolve26(!err);
         });
       });
     } catch {
@@ -14540,11 +15792,11 @@ var init_listen = __esm({
         return this._ready;
       }
       async start() {
-        return new Promise((resolve23, reject) => {
+        return new Promise((resolve26, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("Whisper fallback: model load timeout (5 min). First run downloads the model."));
           }, 3e5);
-          this.process = spawn7("python3", [
+          this.process = spawn8("python3", [
             this.scriptPath,
             "--model",
             this.model,
@@ -14568,7 +15820,7 @@ var init_listen = __esm({
                   this._ready = true;
                   clearTimeout(timeout);
                   this.emit("ready");
-                  resolve23();
+                  resolve26();
                   break;
                 case "transcript":
                   this.emit("transcript", {
@@ -14673,7 +15925,7 @@ var init_listen = __esm({
         }
         if (!this.transcribeCliAvailable) {
           try {
-            execSync15("which transcribe-cli", { stdio: "pipe" });
+            execSync17("which transcribe-cli", { stdio: "pipe" });
             this.transcribeCliAvailable = true;
           } catch {
             this.transcribeCliAvailable = false;
@@ -14690,29 +15942,29 @@ var init_listen = __esm({
         } catch {
         }
         try {
-          const globalRoot = execSync15("npm root -g", {
+          const globalRoot = execSync17("npm root -g", {
             encoding: "utf-8",
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           }).trim();
-          const tcPath = join23(globalRoot, "transcribe-cli");
-          if (existsSync18(join23(tcPath, "dist", "index.js"))) {
+          const tcPath = join27(globalRoot, "transcribe-cli");
+          if (existsSync19(join27(tcPath, "dist", "index.js"))) {
             const { createRequire: createRequire4 } = await import("node:module");
             const req = createRequire4(import.meta.url);
-            return req(join23(tcPath, "dist", "index.js"));
+            return req(join27(tcPath, "dist", "index.js"));
           }
         } catch {
         }
-        const nvmBase = join23(homedir8(), ".nvm", "versions", "node");
-        if (existsSync18(nvmBase)) {
+        const nvmBase = join27(homedir8(), ".nvm", "versions", "node");
+        if (existsSync19(nvmBase)) {
           try {
             const { readdirSync: readdirSync11 } = await import("node:fs");
             for (const ver of readdirSync11(nvmBase)) {
-              const tcPath = join23(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
-              if (existsSync18(join23(tcPath, "dist", "index.js"))) {
+              const tcPath = join27(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
+              if (existsSync19(join27(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
                 const req = createRequire4(import.meta.url);
-                return req(join23(tcPath, "dist", "index.js"));
+                return req(join27(tcPath, "dist", "index.js"));
               }
             }
           } catch {
@@ -14740,7 +15992,7 @@ var init_listen = __esm({
           }
           if (!tc) {
             try {
-              execSync15("npm i -g transcribe-cli", { stdio: "pipe", timeout: 18e4 });
+              execSync17("npm i -g transcribe-cli", { stdio: "pipe", timeout: 18e4 });
               this.transcribeCliAvailable = null;
               tc = await this.loadTranscribeCli();
             } catch {
@@ -14772,11 +16024,11 @@ var init_listen = __esm({
               this.liveTranscriber.on("error", (err) => {
                 this.emit("error", err);
               });
-              await new Promise((resolve23, reject) => {
+              await new Promise((resolve26, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Model load timeout (60s)")), 6e4);
                 this.liveTranscriber.on("ready", () => {
                   clearTimeout(timeout);
-                  resolve23();
+                  resolve26();
                 });
                 this.liveTranscriber.on("error", (err) => {
                   clearTimeout(timeout);
@@ -14826,7 +16078,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
             return `Failed to start live transcription: ${msg}${tcHint}`;
           }
         }
-        this.micProcess = spawn7(micCmd.cmd, micCmd.args, {
+        this.micProcess = spawn8(micCmd.cmd, micCmd.args, {
           stdio: ["pipe", "pipe", "pipe"],
           env: { ...process.env }
         });
@@ -14921,7 +16173,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
         }
         if (!tc) {
           try {
-            execSync15("npm i -g transcribe-cli", { stdio: "pipe", timeout: 18e4 });
+            execSync17("npm i -g transcribe-cli", { stdio: "pipe", timeout: 18e4 });
             this.transcribeCliAvailable = null;
             tc = await this.loadTranscribeCli();
           } catch {
@@ -14938,9 +16190,9 @@ transcribe-cli error: ${transcribeCliError}` : "";
           });
           if (outputDir) {
             const { basename: basename14 } = await import("node:path");
-            const transcriptDir = join23(outputDir, ".oa", "transcripts");
+            const transcriptDir = join27(outputDir, ".oa", "transcripts");
             mkdirSync5(transcriptDir, { recursive: true });
-            const outFile = join23(transcriptDir, `${basename14(filePath)}.txt`);
+            const outFile = join27(transcriptDir, `${basename14(filePath)}.txt`);
             writeFileSync5(outFile, result.text, "utf-8");
           }
           return {
@@ -16220,8 +17472,8 @@ Approach this task thoughtfully:
 });
 
 // packages/prompts/dist/index.js
-import { join as join24, dirname as dirname9 } from "node:path";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { join as join28, dirname as dirname10 } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 var _dir, _packageRoot;
 var init_dist6 = __esm({
   "packages/prompts/dist/index.js"() {
@@ -16230,25 +17482,25 @@ var init_dist6 = __esm({
     init_render2();
     init_task_templates();
     init_render2();
-    _dir = dirname9(fileURLToPath6(import.meta.url));
-    _packageRoot = join24(_dir, "..");
+    _dir = dirname10(fileURLToPath7(import.meta.url));
+    _packageRoot = join28(_dir, "..");
   }
 });
 
 // packages/cli/dist/tui/oa-directory.js
-import { existsSync as existsSync19, mkdirSync as mkdirSync6, readFileSync as readFileSync13, writeFileSync as writeFileSync6, readdirSync as readdirSync7, statSync as statSync9, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join25, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync6, readdirSync as readdirSync7, statSync as statSync9, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join29, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 function initOaDirectory(repoRoot) {
-  const oaPath = join25(repoRoot, OA_DIR);
+  const oaPath = join29(repoRoot, OA_DIR);
   for (const sub of SUBDIRS) {
-    mkdirSync6(join25(oaPath, sub), { recursive: true });
+    mkdirSync6(join29(oaPath, sub), { recursive: true });
   }
   try {
-    const gitignorePath = join25(repoRoot, ".gitignore");
+    const gitignorePath = join29(repoRoot, ".gitignore");
     const settingsPattern = ".oa/settings.json";
-    if (existsSync19(gitignorePath)) {
-      const content = readFileSync13(gitignorePath, "utf-8");
+    if (existsSync20(gitignorePath)) {
+      const content = readFileSync14(gitignorePath, "utf-8");
       if (!content.includes(settingsPattern)) {
         writeFileSync6(gitignorePath, content.trimEnd() + "\n" + settingsPattern + "\n", "utf-8");
       }
@@ -16258,41 +17510,41 @@ function initOaDirectory(repoRoot) {
   return oaPath;
 }
 function hasOaDirectory(repoRoot) {
-  return existsSync19(join25(repoRoot, OA_DIR, "index"));
+  return existsSync20(join29(repoRoot, OA_DIR, "index"));
 }
 function loadProjectSettings(repoRoot) {
-  const settingsPath = join25(repoRoot, OA_DIR, "settings.json");
+  const settingsPath = join29(repoRoot, OA_DIR, "settings.json");
   try {
-    if (existsSync19(settingsPath)) {
-      return JSON.parse(readFileSync13(settingsPath, "utf-8"));
+    if (existsSync20(settingsPath)) {
+      return JSON.parse(readFileSync14(settingsPath, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveProjectSettings(repoRoot, settings) {
-  const oaPath = join25(repoRoot, OA_DIR);
+  const oaPath = join29(repoRoot, OA_DIR);
   mkdirSync6(oaPath, { recursive: true });
   const existing = loadProjectSettings(repoRoot);
   const merged = { ...existing, ...settings };
-  writeFileSync6(join25(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync6(join29(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function loadGlobalSettings() {
-  const settingsPath = join25(homedir9(), ".open-agents", "settings.json");
+  const settingsPath = join29(homedir9(), ".open-agents", "settings.json");
   try {
-    if (existsSync19(settingsPath)) {
-      return JSON.parse(readFileSync13(settingsPath, "utf-8"));
+    if (existsSync20(settingsPath)) {
+      return JSON.parse(readFileSync14(settingsPath, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveGlobalSettings(settings) {
-  const dir = join25(homedir9(), ".open-agents");
+  const dir = join29(homedir9(), ".open-agents");
   mkdirSync6(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
-  writeFileSync6(join25(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync6(join29(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function resolveSettings(repoRoot) {
   const global = loadGlobalSettings();
@@ -16307,12 +17559,12 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   while (dir && !visited.has(dir)) {
     visited.add(dir);
     for (const name of CONTEXT_FILES) {
-      const filePath = join25(dir, name);
+      const filePath = join29(dir, name);
       const normalizedName = name.toLowerCase();
-      if (existsSync19(filePath) && !seen.has(filePath)) {
+      if (existsSync20(filePath) && !seen.has(filePath)) {
         seen.add(filePath);
         try {
-          let content = readFileSync13(filePath, "utf-8");
+          let content = readFileSync14(filePath, "utf-8");
           if (content.length > maxContentLen) {
             content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
           }
@@ -16326,11 +17578,11 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
         }
       }
     }
-    const projectMap = join25(dir, OA_DIR, "context", "project-map.md");
-    if (existsSync19(projectMap) && !seen.has(projectMap)) {
+    const projectMap = join29(dir, OA_DIR, "context", "project-map.md");
+    if (existsSync20(projectMap) && !seen.has(projectMap)) {
       seen.add(projectMap);
       try {
-        let content = readFileSync13(projectMap, "utf-8");
+        let content = readFileSync14(projectMap, "utf-8");
         if (content.length > maxContentLen) {
           content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
         }
@@ -16342,7 +17594,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
       } catch {
       }
     }
-    const parent = join25(dir, "..");
+    const parent = join29(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -16360,9 +17612,9 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   return found;
 }
 function readIndexMeta(repoRoot) {
-  const metaPath = join25(repoRoot, OA_DIR, "index", "meta.json");
+  const metaPath = join29(repoRoot, OA_DIR, "index", "meta.json");
   try {
-    return JSON.parse(readFileSync13(metaPath, "utf-8"));
+    return JSON.parse(readFileSync14(metaPath, "utf-8"));
   } catch {
     return null;
   }
@@ -16413,28 +17665,28 @@ ${tree}\`\`\`
     sections.push("");
   }
   const content = sections.join("\n");
-  const contextDir = join25(repoRoot, OA_DIR, "context");
+  const contextDir = join29(repoRoot, OA_DIR, "context");
   mkdirSync6(contextDir, { recursive: true });
-  writeFileSync6(join25(contextDir, "project-map.md"), content, "utf-8");
+  writeFileSync6(join29(contextDir, "project-map.md"), content, "utf-8");
   return content;
 }
 function saveSession(repoRoot, session) {
-  const historyDir = join25(repoRoot, OA_DIR, "history");
+  const historyDir = join29(repoRoot, OA_DIR, "history");
   mkdirSync6(historyDir, { recursive: true });
-  writeFileSync6(join25(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+  writeFileSync6(join29(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
 }
 function loadRecentSessions(repoRoot, limit = 5) {
-  const historyDir = join25(repoRoot, OA_DIR, "history");
-  if (!existsSync19(historyDir))
+  const historyDir = join29(repoRoot, OA_DIR, "history");
+  if (!existsSync20(historyDir))
     return [];
   try {
     const files = readdirSync7(historyDir).filter((f) => f.endsWith(".json") && f !== "pending-task.json").map((f) => {
-      const stat5 = statSync9(join25(historyDir, f));
+      const stat5 = statSync9(join29(historyDir, f));
       return { file: f, mtime: stat5.mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
     return files.map((f) => {
       try {
-        return JSON.parse(readFileSync13(join25(historyDir, f.file), "utf-8"));
+        return JSON.parse(readFileSync14(join29(historyDir, f.file), "utf-8"));
       } catch {
         return null;
       }
@@ -16444,16 +17696,16 @@ function loadRecentSessions(repoRoot, limit = 5) {
   }
 }
 function savePendingTask(repoRoot, task) {
-  const historyDir = join25(repoRoot, OA_DIR, "history");
+  const historyDir = join29(repoRoot, OA_DIR, "history");
   mkdirSync6(historyDir, { recursive: true });
-  writeFileSync6(join25(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
+  writeFileSync6(join29(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
 }
 function loadPendingTask(repoRoot) {
-  const filePath = join25(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
+  const filePath = join29(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
   try {
-    if (!existsSync19(filePath))
+    if (!existsSync20(filePath))
       return null;
-    const data = JSON.parse(readFileSync13(filePath, "utf-8"));
+    const data = JSON.parse(readFileSync14(filePath, "utf-8"));
     try {
       unlinkSync3(filePath);
     } catch {
@@ -16464,13 +17716,13 @@ function loadPendingTask(repoRoot) {
   }
 }
 function saveSessionContext(repoRoot, entry) {
-  const contextDir = join25(repoRoot, OA_DIR, "context");
+  const contextDir = join29(repoRoot, OA_DIR, "context");
   mkdirSync6(contextDir, { recursive: true });
-  const filePath = join25(contextDir, CONTEXT_SAVE_FILE);
+  const filePath = join29(contextDir, CONTEXT_SAVE_FILE);
   let ctx;
   try {
-    if (existsSync19(filePath)) {
-      ctx = JSON.parse(readFileSync13(filePath, "utf-8"));
+    if (existsSync20(filePath)) {
+      ctx = JSON.parse(readFileSync14(filePath, "utf-8"));
     } else {
       ctx = { entries: [], maxEntries: MAX_CONTEXT_ENTRIES, updatedAt: "" };
     }
@@ -16485,11 +17737,11 @@ function saveSessionContext(repoRoot, entry) {
   writeFileSync6(filePath, JSON.stringify(ctx, null, 2) + "\n", "utf-8");
 }
 function loadSessionContext(repoRoot) {
-  const filePath = join25(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
+  const filePath = join29(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
   try {
-    if (!existsSync19(filePath))
+    if (!existsSync20(filePath))
       return null;
-    return JSON.parse(readFileSync13(filePath, "utf-8"));
+    return JSON.parse(readFileSync14(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -16536,12 +17788,12 @@ function detectManifests(repoRoot) {
     { file: "docker-compose.yaml", type: "Docker Compose" }
   ];
   for (const check of checks) {
-    const filePath = join25(repoRoot, check.file);
-    if (existsSync19(filePath)) {
+    const filePath = join29(repoRoot, check.file);
+    if (existsSync20(filePath)) {
       let name;
       if (check.nameField) {
         try {
-          const data = JSON.parse(readFileSync13(filePath, "utf-8"));
+          const data = JSON.parse(readFileSync14(filePath, "utf-8"));
           name = data[check.nameField];
         } catch {
         }
@@ -16570,7 +17822,7 @@ function findKeyFiles(repoRoot) {
     { pattern: "CLAUDE.md", description: "Claude Code context" }
   ];
   for (const check of checks) {
-    if (existsSync19(join25(repoRoot, check.pattern))) {
+    if (existsSync20(join29(repoRoot, check.pattern))) {
       keyFiles.push({ path: check.pattern, description: check.description });
     }
   }
@@ -16596,12 +17848,12 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
       if (entry.isDirectory()) {
         let fileCount = 0;
         try {
-          fileCount = readdirSync7(join25(root, entry.name)).filter((f) => !f.startsWith(".")).length;
+          fileCount = readdirSync7(join29(root, entry.name)).filter((f) => !f.startsWith(".")).length;
         } catch {
         }
         result += `${prefix}${connector}${entry.name}/ (${fileCount})
 `;
-        result += buildDirTree(join25(root, entry.name), maxDepth, childPrefix, depth + 1);
+        result += buildDirTree(join29(root, entry.name), maxDepth, childPrefix, depth + 1);
       } else if (depth < maxDepth) {
         result += `${prefix}${connector}${entry.name}
 `;
@@ -16654,9 +17906,9 @@ var init_oa_directory = __esm({
 
 // packages/cli/dist/tui/setup.js
 import * as readline from "node:readline";
-import { execSync as execSync16, spawn as spawn8 } from "node:child_process";
-import { existsSync as existsSync20, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join26 } from "node:path";
+import { execSync as execSync18, spawn as spawn9 } from "node:child_process";
+import { existsSync as existsSync21, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join30 } from "node:path";
 import { homedir as homedir10, platform } from "node:os";
 function detectSystemSpecs() {
   let totalRamGB = 0;
@@ -16664,7 +17916,7 @@ function detectSystemSpecs() {
   let gpuVramGB = 0;
   let gpuName = "";
   try {
-    const memInfo = execSync16("free -b 2>/dev/null || sysctl -n hw.memsize 2>/dev/null", {
+    const memInfo = execSync18("free -b 2>/dev/null || sysctl -n hw.memsize 2>/dev/null", {
       encoding: "utf8",
       timeout: 5e3
     });
@@ -16684,7 +17936,7 @@ function detectSystemSpecs() {
   } catch {
   }
   try {
-    const nvidiaSmi = execSync16("nvidia-smi --query-gpu=memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 5e3 });
+    const nvidiaSmi = execSync18("nvidia-smi --query-gpu=memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 5e3 });
     const lines = nvidiaSmi.trim().split("\n");
     if (lines.length > 0) {
       for (const line of lines) {
@@ -16740,12 +17992,12 @@ function modelSupportsToolCalling(modelName) {
   return false;
 }
 function ask(rl, question) {
-  return new Promise((resolve23) => {
-    rl.question(question, (answer) => resolve23(answer.trim()));
+  return new Promise((resolve26) => {
+    rl.question(question, (answer) => resolve26(answer.trim()));
   });
 }
 function askSecret(rl, question) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve26) => {
     process.stdout.write(question);
     let secret = "";
     const stdin = process.stdin;
@@ -16763,7 +18015,7 @@ function askSecret(rl, question) {
             stdin.setRawMode(hadRawMode ?? false);
           }
           process.stdout.write("\n");
-          resolve23(secret.trim());
+          resolve26(secret.trim());
           return;
         } else if (c3 === "") {
           stdin.removeListener("data", onData);
@@ -16771,7 +18023,7 @@ function askSecret(rl, question) {
             stdin.setRawMode(hadRawMode ?? false);
           }
           process.stdout.write("\n");
-          resolve23("");
+          resolve26("");
           return;
         } else if (c3 === "\x7F" || c3 === "\b") {
           if (secret.length > 0) {
@@ -16809,7 +18061,7 @@ function installOllamaLinux() {
 
 `);
   try {
-    execSync16("curl -fsSL https://ollama.com/install.sh | sh", {
+    execSync18("curl -fsSL https://ollama.com/install.sh | sh", {
       stdio: "inherit",
       timeout: 3e5
     });
@@ -16848,10 +18100,10 @@ async function installOllamaMac(rl) {
 
 `);
     try {
-      execSync16('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"', { stdio: "inherit", timeout: 6e5 });
+      execSync18('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"', { stdio: "inherit", timeout: 6e5 });
       if (!hasCmd("brew")) {
         try {
-          const brewPrefix = existsSync20("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
+          const brewPrefix = existsSync21("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
           process.env["PATH"] = `${brewPrefix}/bin:${process.env["PATH"]}`;
         } catch {
         }
@@ -16881,7 +18133,7 @@ async function installOllamaMac(rl) {
 
 `);
   try {
-    execSync16("brew install ollama", {
+    execSync18("brew install ollama", {
       stdio: "inherit",
       timeout: 3e5
     });
@@ -16908,7 +18160,7 @@ function installOllamaWindows() {
 
 `);
   try {
-    execSync16('powershell -Command "irm https://ollama.com/install.ps1 | iex"', {
+    execSync18('powershell -Command "irm https://ollama.com/install.ps1 | iex"', {
       stdio: "inherit",
       timeout: 3e5
     });
@@ -16931,7 +18183,7 @@ function installOllamaWindows() {
 }
 function pullModelWithAutoUpdate(tag) {
   try {
-    execSync16(`ollama pull ${tag}`, {
+    execSync18(`ollama pull ${tag}`, {
       stdio: "inherit",
       timeout: 36e5
       // 1 hour max
@@ -16948,7 +18200,7 @@ function pullModelWithAutoUpdate(tag) {
 
 `);
       try {
-        execSync16("curl -fsSL https://ollama.com/install.sh | sh", {
+        execSync18("curl -fsSL https://ollama.com/install.sh | sh", {
           stdio: "inherit",
           timeout: 3e5
           // 5 min max for install
@@ -16959,7 +18211,7 @@ function pullModelWithAutoUpdate(tag) {
         process.stdout.write(`  ${c2.cyan("\u25CF")} Retrying pull of ${c2.bold(tag)}...
 
 `);
-        execSync16(`ollama pull ${tag}`, {
+        execSync18(`ollama pull ${tag}`, {
           stdio: "inherit",
           timeout: 36e5
         });
@@ -17140,9 +18392,9 @@ async function doSetup(config, rl) {
   ${c2.cyan("\u25CF")} Starting ollama serve in background...
 `);
         try {
-          const child = spawn8("ollama", ["serve"], { stdio: "ignore", detached: true });
+          const child = spawn9("ollama", ["serve"], { stdio: "ignore", detached: true });
           child.unref();
-          await new Promise((resolve23) => setTimeout(resolve23, 3e3));
+          await new Promise((resolve26) => setTimeout(resolve26, 3e3));
           try {
             models = await fetchOllamaModels(config.backendUrl);
             process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -17168,9 +18420,9 @@ async function doSetup(config, rl) {
   ${c2.cyan("\u25CF")} Starting ollama serve...
 `);
           try {
-            const child = spawn8("ollama", ["serve"], { stdio: "ignore", detached: true });
+            const child = spawn9("ollama", ["serve"], { stdio: "ignore", detached: true });
             child.unref();
-            await new Promise((resolve23) => setTimeout(resolve23, 3e3));
+            await new Promise((resolve26) => setTimeout(resolve26, 3e3));
             try {
               models = await fetchOllamaModels(config.backendUrl);
               process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -17325,12 +18577,12 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict ${numPredict}`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir2 = join26(homedir10(), ".open-agents", "models");
+        const modelDir2 = join30(homedir10(), ".open-agents", "models");
         mkdirSync7(modelDir2, { recursive: true });
-        const modelfilePath = join26(modelDir2, `Modelfile.${customName}`);
+        const modelfilePath = join30(modelDir2, `Modelfile.${customName}`);
         writeFileSync7(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
-        execSync16(`ollama create ${customName} -f ${modelfilePath}`, {
+        execSync18(`ollama create ${customName} -f ${modelfilePath}`, {
           stdio: "pipe",
           timeout: 12e4
         });
@@ -17373,7 +18625,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync20(join26(homedir10(), ".open-agents", "config.json"));
+    return !existsSync21(join30(homedir10(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -17381,7 +18633,7 @@ function isFirstRun() {
 function hasCmd(cmd) {
   try {
     const whichCmd = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
-    execSync16(whichCmd, { stdio: "pipe", timeout: 3e3 });
+    execSync18(whichCmd, { stdio: "pipe", timeout: 3e3 });
     return true;
   } catch {
     return false;
@@ -17410,11 +18662,11 @@ function detectPkgManager() {
   return null;
 }
 function getVenvDir() {
-  return join26(homedir10(), ".open-agents", "venv");
+  return join30(homedir10(), ".open-agents", "venv");
 }
 function hasVenvModule() {
   try {
-    execSync16("python3 -m venv --help", { stdio: "pipe", timeout: 5e3 });
+    execSync18("python3 -m venv --help", { stdio: "pipe", timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -17422,8 +18674,8 @@ function hasVenvModule() {
 }
 function ensureVenv(log) {
   const venvDir = getVenvDir();
-  const venvPip = join26(venvDir, "bin", "pip");
-  if (existsSync20(venvPip))
+  const venvPip = join30(venvDir, "bin", "pip");
+  if (existsSync21(venvPip))
     return venvDir;
   log("Creating Python venv for vision deps...");
   if (!hasCmd("python3")) {
@@ -17435,9 +18687,9 @@ function ensureVenv(log) {
     return null;
   }
   try {
-    mkdirSync7(join26(homedir10(), ".open-agents"), { recursive: true });
-    execSync16(`python3 -m venv "${venvDir}"`, { stdio: "pipe", timeout: 3e4 });
-    execSync16(`"${join26(venvDir, "bin", "pip")}" install --upgrade pip`, {
+    mkdirSync7(join30(homedir10(), ".open-agents"), { recursive: true });
+    execSync18(`python3 -m venv "${venvDir}"`, { stdio: "pipe", timeout: 3e4 });
+    execSync18(`"${join30(venvDir, "bin", "pip")}" install --upgrade pip`, {
       stdio: "pipe",
       timeout: 6e4
     });
@@ -17450,7 +18702,7 @@ function ensureVenv(log) {
 }
 function trySudoPasswordless(cmd, timeoutMs = 12e4) {
   try {
-    execSync16(`sudo -n ${cmd}`, {
+    execSync18(`sudo -n ${cmd}`, {
       stdio: "pipe",
       timeout: timeoutMs,
       env: { ...process.env, DEBIAN_FRONTEND: "noninteractive" }
@@ -17462,7 +18714,7 @@ function trySudoPasswordless(cmd, timeoutMs = 12e4) {
 }
 function runWithSudo(cmd, password, timeoutMs = 12e4) {
   try {
-    execSync16(`sudo -S ${cmd}`, {
+    execSync18(`sudo -S ${cmd}`, {
       input: password + "\n",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: timeoutMs,
@@ -17522,7 +18774,7 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
       } else {
         log("Installing tesseract-ocr...");
         try {
-          execSync16(pkg.cmd, { stdio: "pipe", timeout: 12e4 });
+          execSync18(pkg.cmd, { stdio: "pipe", timeout: 12e4 });
           if (hasCmd("tesseract")) {
             log("tesseract-ocr installed successfully.");
           } else {
@@ -17594,7 +18846,7 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
       } else {
         log(`Installing ${dep.label}...`);
         try {
-          execSync16(pkg.cmd, { stdio: "pipe", timeout: 12e4 });
+          execSync18(pkg.cmd, { stdio: "pipe", timeout: 12e4 });
           if (hasCmd(dep.binary)) {
             log(`${dep.label} installed successfully.`);
           } else {
@@ -17625,7 +18877,7 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     const venvCmds = {
       apt: () => {
         try {
-          const pyVer = execSync16(`python3 -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"`, { encoding: "utf8", stdio: "pipe", timeout: 5e3 }).trim();
+          const pyVer = execSync18(`python3 -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"`, { encoding: "utf8", stdio: "pipe", timeout: 5e3 }).trim();
           return `apt-get install -y python3-venv python${pyVer}-venv`;
         } catch {
           return "apt-get install -y python3-venv";
@@ -17646,19 +18898,19 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   const venvDir = getVenvDir();
-  const venvBin = join26(venvDir, "bin");
-  const venvMoondream = join26(venvBin, "moondream-station");
+  const venvBin = join30(venvDir, "bin");
+  const venvMoondream = join30(venvBin, "moondream-station");
   const venv = ensureVenv(log);
-  if (venv && !hasCmd("moondream-station") && !existsSync20(venvMoondream)) {
-    const venvPip = join26(venvBin, "pip");
+  if (venv && !hasCmd("moondream-station") && !existsSync21(venvMoondream)) {
+    const venvPip = join30(venvBin, "pip");
     log("Installing moondream-station in ~/.open-agents/venv...");
     try {
-      execSync16(`"${venvPip}" install moondream-station`, { stdio: "pipe", timeout: 3e5 });
-      if (existsSync20(venvMoondream)) {
+      execSync18(`"${venvPip}" install moondream-station`, { stdio: "pipe", timeout: 3e5 });
+      if (existsSync21(venvMoondream)) {
         log("moondream-station installed successfully.");
       } else {
         try {
-          const check = execSync16(`"${venvPip}" show moondream-station`, { encoding: "utf8", stdio: "pipe", timeout: 5e3 });
+          const check = execSync18(`"${venvPip}" show moondream-station`, { encoding: "utf8", stdio: "pipe", timeout: 5e3 });
           if (check.includes("moondream")) {
             log("moondream-station package installed.");
           }
@@ -17671,11 +18923,11 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   if (venv) {
-    const venvPython = join26(venvBin, "python");
-    const venvPip2 = join26(venvBin, "pip");
+    const venvPython = join30(venvBin, "python");
+    const venvPip2 = join30(venvBin, "pip");
     let ocrStackInstalled = false;
     try {
-      execSync16(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
+      execSync18(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
       ocrStackInstalled = true;
     } catch {
     }
@@ -17683,9 +18935,9 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
       const ocrPackages = "pytesseract Pillow opencv-python-headless numpy";
       log("Installing OCR Python stack (pytesseract, OpenCV, Pillow, numpy)...");
       try {
-        execSync16(`"${venvPip2}" install ${ocrPackages}`, { stdio: "pipe", timeout: 3e5 });
+        execSync18(`"${venvPip2}" install ${ocrPackages}`, { stdio: "pipe", timeout: 3e5 });
         try {
-          execSync16(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
+          execSync18(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
           log("OCR Python stack installed successfully.");
         } catch {
           log("OCR Python stack install completed but import verification failed.");
@@ -17732,11 +18984,11 @@ function createExpandedVariant(baseModel, specs, sizeGB) {
       `PARAMETER num_predict ${numPredict}`,
       `PARAMETER stop "<|endoftext|>"`
     ].join("\n");
-    const modelDir2 = join26(homedir10(), ".open-agents", "models");
+    const modelDir2 = join30(homedir10(), ".open-agents", "models");
     mkdirSync7(modelDir2, { recursive: true });
-    const modelfilePath = join26(modelDir2, `Modelfile.${customName}`);
+    const modelfilePath = join30(modelDir2, `Modelfile.${customName}`);
     writeFileSync7(modelfilePath, modelfileContent + "\n", "utf8");
-    execSync16(`ollama create ${customName} -f ${modelfilePath}`, {
+    execSync18(`ollama create ${customName} -f ${modelfilePath}`, {
       stdio: "pipe",
       timeout: 12e4
     });
@@ -18522,18 +19774,18 @@ async function handleUpdate(subcommand, ctx) {
   let currentVersion = "0.0.0";
   try {
     const { createRequire: createRequire4 } = await import("node:module");
-    const { fileURLToPath: fileURLToPath9 } = await import("node:url");
-    const { dirname: dirname12, join: join37 } = await import("node:path");
-    const { existsSync: existsSync27 } = await import("node:fs");
+    const { fileURLToPath: fileURLToPath10 } = await import("node:url");
+    const { dirname: dirname13, join: join41 } = await import("node:path");
+    const { existsSync: existsSync28 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
-    const thisDir = dirname12(fileURLToPath9(import.meta.url));
+    const thisDir = dirname13(fileURLToPath10(import.meta.url));
     const candidates = [
-      join37(thisDir, "..", "package.json"),
-      join37(thisDir, "..", "..", "package.json"),
-      join37(thisDir, "..", "..", "..", "package.json")
+      join41(thisDir, "..", "package.json"),
+      join41(thisDir, "..", "..", "package.json"),
+      join41(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync27(pkgPath)) {
+      if (existsSync28(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -18571,8 +19823,8 @@ async function handleUpdate(subcommand, ctx) {
   checkSpinner.stop(`Update available: v${info.currentVersion} \u2192 v${c2.bold(c2.green(info.latestVersion))}`);
   const installSpinner = startInlineSpinner("Installing update");
   const { exec } = await import("node:child_process");
-  const installOk = await new Promise((resolve23) => {
-    const child = exec(`npm cache clean --force open-agents-ai 2>/dev/null; npm install -g open-agents-ai@latest --force`, { timeout: 18e4 }, (err) => resolve23(!err));
+  const installOk = await new Promise((resolve26) => {
+    const child = exec(`npm cache clean --force open-agents-ai 2>/dev/null; npm install -g open-agents-ai@latest --force`, { timeout: 18e4 }, (err) => resolve26(!err));
     child.stdout?.resume();
     child.stderr?.resume();
   });
@@ -18665,9 +19917,9 @@ var init_commands = __esm({
 });
 
 // packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync21, readFileSync as readFileSync14, readdirSync as readdirSync8 } from "node:fs";
-import { join as join27, basename as basename10 } from "node:path";
-import { execSync as execSync17 } from "node:child_process";
+import { existsSync as existsSync22, readFileSync as readFileSync15, readdirSync as readdirSync8 } from "node:fs";
+import { join as join31, basename as basename10 } from "node:path";
+import { execSync as execSync19 } from "node:child_process";
 import { homedir as homedir11, platform as platform2, release } from "node:os";
 function getModelTier(modelName) {
   const m = modelName.toLowerCase();
@@ -18701,10 +19953,10 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath = join27(repoRoot, OA_DIR, "context", "project-map.md");
-  if (existsSync21(mapPath)) {
+  const mapPath = join31(repoRoot, OA_DIR, "context", "project-map.md");
+  if (existsSync22(mapPath)) {
     try {
-      const content = readFileSync14(mapPath, "utf-8");
+      const content = readFileSync15(mapPath, "utf-8");
       return content;
     } catch {
     }
@@ -18713,19 +19965,19 @@ function loadProjectMap(repoRoot) {
 }
 function getGitInfo(repoRoot) {
   try {
-    execSync17("git rev-parse --is-inside-work-tree", { cwd: repoRoot, stdio: "pipe" });
+    execSync19("git rev-parse --is-inside-work-tree", { cwd: repoRoot, stdio: "pipe" });
   } catch {
     return "";
   }
   const lines = [];
   try {
-    const branch = execSync17("git branch --show-current", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
+    const branch = execSync19("git branch --show-current", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
     if (branch)
       lines.push(`Branch: ${branch}`);
   } catch {
   }
   try {
-    const status = execSync17("git status --porcelain", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
+    const status = execSync19("git status --porcelain", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
     if (status) {
       const changed = status.split("\n").length;
       lines.push(`Working tree: ${changed} changed file(s)`);
@@ -18735,7 +19987,7 @@ function getGitInfo(repoRoot) {
   } catch {
   }
   try {
-    const log = execSync17("git log --oneline -5 --no-decorate", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
+    const log = execSync19("git log --oneline -5 --no-decorate", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
     if (log)
       lines.push(`Recent commits:
 ${log}`);
@@ -18745,31 +19997,31 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join27(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join31(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join27(repoRoot, ".open-agents", "memory");
-  if (legacyMemDir !== oaMemDir && existsSync21(legacyMemDir)) {
+  const legacyMemDir = join31(repoRoot, ".open-agents", "memory");
+  if (legacyMemDir !== oaMemDir && existsSync22(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join27(homedir11(), ".open-agents", "memory");
+  const globalMemDir = join31(homedir11(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync21(memDir))
+  if (!existsSync22(memDir))
     return "";
   const lines = [];
   try {
     const files = readdirSync8(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync14(join27(memDir, file), "utf-8");
+        const raw = readFileSync15(join31(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
         const topic = basename10(file, ".json");
         const keys = Object.keys(entries);
@@ -19796,22 +21048,22 @@ var init_carousel = __esm({
 });
 
 // packages/cli/dist/tui/carousel-descriptors.js
-import { existsSync as existsSync22, readFileSync as readFileSync15, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, readdirSync as readdirSync9 } from "node:fs";
-import { join as join28, basename as basename11 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync16, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, readdirSync as readdirSync9 } from "node:fs";
+import { join as join32, basename as basename11 } from "node:path";
 function loadToolProfile(repoRoot) {
-  const filePath = join28(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
+  const filePath = join32(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
   try {
-    if (!existsSync22(filePath))
+    if (!existsSync23(filePath))
       return null;
-    return JSON.parse(readFileSync15(filePath, "utf-8"));
+    return JSON.parse(readFileSync16(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveToolProfile(repoRoot, profile) {
-  const contextDir = join28(repoRoot, OA_DIR, "context");
+  const contextDir = join32(repoRoot, OA_DIR, "context");
   mkdirSync8(contextDir, { recursive: true });
-  writeFileSync8(join28(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+  writeFileSync8(join32(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
 }
 function categorizeToolCall(toolName) {
   for (const cat of TOOL_CATEGORIES) {
@@ -19869,25 +21121,25 @@ function weightedColor(profile) {
   return selectedCat.colors[Math.floor(Math.random() * selectedCat.colors.length)];
 }
 function loadCachedDescriptors(repoRoot) {
-  const filePath = join28(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
+  const filePath = join32(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
   try {
-    if (!existsSync22(filePath))
+    if (!existsSync23(filePath))
       return null;
-    const cached = JSON.parse(readFileSync15(filePath, "utf-8"));
+    const cached = JSON.parse(readFileSync16(filePath, "utf-8"));
     return cached.phrases.length > 0 ? cached.phrases : null;
   } catch {
     return null;
   }
 }
 function saveCachedDescriptors(repoRoot, phrases, sourceHash) {
-  const contextDir = join28(repoRoot, OA_DIR, "context");
+  const contextDir = join32(repoRoot, OA_DIR, "context");
   mkdirSync8(contextDir, { recursive: true });
   const cached = {
     phrases,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash
   };
-  writeFileSync8(join28(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
+  writeFileSync8(join32(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
 }
 function generateDescriptors(repoRoot) {
   const profile = loadToolProfile(repoRoot);
@@ -19935,11 +21187,11 @@ function generateDescriptors(repoRoot) {
   return phrases;
 }
 function extractFromPackageJson(repoRoot, tags) {
-  const pkgPath = join28(repoRoot, "package.json");
+  const pkgPath = join32(repoRoot, "package.json");
   try {
-    if (!existsSync22(pkgPath))
+    if (!existsSync23(pkgPath))
       return;
-    const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
     if (pkg.name && typeof pkg.name === "string") {
       const parts = pkg.name.replace(/^@/, "").split("/");
       for (const p of parts)
@@ -19983,7 +21235,7 @@ function extractFromManifests(repoRoot, tags) {
     { file: ".github/workflows", tag: "ci/cd" }
   ];
   for (const check of manifestChecks) {
-    if (existsSync22(join28(repoRoot, check.file))) {
+    if (existsSync23(join32(repoRoot, check.file))) {
       tags.push(check.tag);
     }
   }
@@ -20005,16 +21257,16 @@ function extractFromSessions(repoRoot, tags) {
   }
 }
 function extractFromMemory(repoRoot, tags) {
-  const memoryDir = join28(repoRoot, OA_DIR, "memory");
+  const memoryDir = join32(repoRoot, OA_DIR, "memory");
   try {
-    if (!existsSync22(memoryDir))
+    if (!existsSync23(memoryDir))
       return;
     const files = readdirSync9(memoryDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       const topic = file.replace(/\.json$/, "").replace(/[-_]/g, " ");
       tags.push(topic);
       try {
-        const data = JSON.parse(readFileSync15(join28(memoryDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync16(join32(memoryDir, file), "utf-8"));
         if (data && typeof data === "object") {
           const keys = Object.keys(data).slice(0, 3);
           for (const key of keys) {
@@ -20149,25 +21401,25 @@ var init_carousel_descriptors = __esm({
 });
 
 // packages/cli/dist/tui/voice.js
-import { existsSync as existsSync23, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readFileSync as readFileSync16, unlinkSync as unlinkSync4 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readFileSync as readFileSync17, unlinkSync as unlinkSync4 } from "node:fs";
+import { join as join33 } from "node:path";
 import { homedir as homedir12, tmpdir as tmpdir6, platform as platform3 } from "node:os";
-import { execSync as execSync18, spawn as nodeSpawn } from "node:child_process";
+import { execSync as execSync20, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 function voiceDir() {
-  return join29(homedir12(), ".open-agents", "voice");
+  return join33(homedir12(), ".open-agents", "voice");
 }
 function modelsDir() {
-  return join29(voiceDir(), "models");
+  return join33(voiceDir(), "models");
 }
 function modelDir(id) {
-  return join29(modelsDir(), id);
+  return join33(modelsDir(), id);
 }
 function modelOnnxPath(id) {
-  return join29(modelDir(id), "model.onnx");
+  return join33(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join29(modelDir(id), "config.json");
+  return join33(modelDir(id), "config.json");
 }
 function describeToolCall(toolName, args, personality = 2) {
   const path = args["path"];
@@ -20242,6 +21494,14 @@ function describeToolCallTerse(toolName, args, file) {
       return `Creating custom tool`;
     case "manage_tools":
       return `Managing custom tools`;
+    case "browser_action":
+      return `Browser ${args["action"] ?? "action"}`;
+    case "scheduler":
+      return `${args["action"] === "create" ? "Scheduling task" : "Checking scheduler"}`;
+    case "reminder":
+      return `${args["action"] === "set" ? "Setting reminder" : "Checking reminders"}`;
+    case "agenda":
+      return `Checking agenda`;
     default:
       return `Using ${toolName}`;
   }
@@ -20288,6 +21548,14 @@ function describeToolCallConversational(toolName, args, file) {
       return `Taking a look at that image`;
     case "screenshot":
       return `Grabbing a screenshot`;
+    case "browser_action":
+      return `Let me ${args["action"] === "navigate" ? "open that page" : args["action"] === "screenshot" ? "grab a screenshot of the browser" : `do a browser ${args["action"] ?? "action"}`}`;
+    case "scheduler":
+      return `${args["action"] === "create" ? "Setting up a scheduled task" : "Checking the schedule"}`;
+    case "reminder":
+      return `${args["action"] === "set" ? "Making a note for next time" : "Looking at reminders"}`;
+    case "agenda":
+      return `Let me check what's on the agenda`;
     default:
       return `Working with ${toolName}`;
   }
@@ -20334,6 +21602,14 @@ function describeToolCallChatty(toolName, args, file) {
       return `Let me get a good look at that image`;
     case "screenshot":
       return `Snapping a screenshot to see what's happening`;
+    case "browser_action":
+      return `Firing up the browser, let's ${args["action"] === "navigate" ? "see what's on that page" : args["action"] === "screenshot" ? "get a visual" : `${args["action"] ?? "do this"}`}`;
+    case "scheduler":
+      return `${args["action"] === "create" ? "Alright, let me set up a recurring task for you" : "Let me pull up the schedule and see what's coming up"}`;
+    case "reminder":
+      return `${args["action"] === "set" ? "Leaving myself a note for future me, don't let me forget" : "Let me check if past me left any reminders"}`;
+    case "agenda":
+      return `Let me see the full picture of what needs doing`;
     default:
       return `Pulling in ${toolName}, hang tight`;
   }
@@ -20589,7 +21865,7 @@ var init_voice = __esm({
         const audioData = result["output"].data;
         if (audioData.length === 0)
           return;
-        const wavPath = join29(tmpdir6(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join33(tmpdir6(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, this.config.audio.sample_rate, wavPath);
         await this.playWav(wavPath);
         try {
@@ -20678,7 +21954,7 @@ var init_voice = __esm({
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
-        return new Promise((resolve23) => {
+        return new Promise((resolve26) => {
           const child = nodeSpawn(cmd[0], cmd.slice(1), {
             stdio: "ignore",
             detached: false
@@ -20687,12 +21963,12 @@ var init_voice = __esm({
           child.on("close", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve23();
+            resolve26();
           });
           child.on("error", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve23();
+            resolve26();
           });
           setTimeout(() => {
             if (this.currentPlayback === child) {
@@ -20702,7 +21978,7 @@ var init_voice = __esm({
               }
               this.currentPlayback = null;
             }
-            resolve23();
+            resolve26();
           }, 15e3);
         });
       }
@@ -20719,7 +21995,7 @@ var init_voice = __esm({
         }
         for (const player of ["paplay", "pw-play", "aplay"]) {
           try {
-            execSync18(`which ${player}`, { stdio: "pipe" });
+            execSync20(`which ${player}`, { stdio: "pipe" });
             return [player, path];
           } catch {
           }
@@ -20744,14 +22020,14 @@ var init_voice = __esm({
         const arch = process.arch;
         const isArmLinux = (arch === "arm64" || arch === "arm") && process.platform === "linux";
         mkdirSync9(voiceDir(), { recursive: true });
-        const pkgPath = join29(voiceDir(), "package.json");
+        const pkgPath = join33(voiceDir(), "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
         };
-        if (existsSync23(pkgPath)) {
+        if (existsSync24(pkgPath)) {
           try {
-            const existing = JSON.parse(readFileSync16(pkgPath, "utf8"));
+            const existing = JSON.parse(readFileSync17(pkgPath, "utf8"));
             if (!existing.dependencies?.["phonemizer"]) {
               existing.dependencies = { ...existing.dependencies, ...expectedDeps };
               writeFileSync9(pkgPath, JSON.stringify(existing, null, 2));
@@ -20759,14 +22035,14 @@ var init_voice = __esm({
           } catch {
           }
         }
-        if (!existsSync23(pkgPath)) {
+        if (!existsSync24(pkgPath)) {
           writeFileSync9(pkgPath, JSON.stringify({
             name: "open-agents-voice",
             private: true,
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join29(voiceDir(), "index.js"));
+        const voiceRequire = createRequire(join33(voiceDir(), "index.js"));
         try {
           this.ort = voiceRequire("onnxruntime-node");
         } catch {
@@ -20775,7 +22051,7 @@ var init_voice = __esm({
           }
           renderInfo("Installing ONNX runtime for voice synthesis...");
           try {
-            execSync18("npm install --no-audit --no-fund", {
+            execSync20("npm install --no-audit --no-fund", {
               cwd: voiceDir(),
               stdio: "pipe",
               timeout: 12e4
@@ -20796,7 +22072,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           }
           renderInfo("Installing phonemizer for voice synthesis...");
           try {
-            execSync18("npm install --no-audit --no-fund", {
+            execSync20("npm install --no-audit --no-fund", {
               cwd: voiceDir(),
               stdio: "pipe",
               timeout: 12e4
@@ -20820,10 +22096,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         const dir = modelDir(id);
         const onnxPath = modelOnnxPath(id);
         const configPath = modelConfigPath(id);
-        if (existsSync23(onnxPath) && existsSync23(configPath))
+        if (existsSync24(onnxPath) && existsSync24(configPath))
           return;
         mkdirSync9(dir, { recursive: true });
-        if (!existsSync23(configPath)) {
+        if (!existsSync24(configPath)) {
           renderInfo(`Downloading ${model.label} voice config...`);
           const configResp = await fetch(model.configUrl);
           if (!configResp.ok)
@@ -20831,7 +22107,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           const configText = await configResp.text();
           writeFileSync9(configPath, configText);
         }
-        if (!existsSync23(onnxPath)) {
+        if (!existsSync24(onnxPath)) {
           renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
           const onnxResp = await fetch(model.onnxUrl);
           if (!onnxResp.ok)
@@ -20867,10 +22143,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           throw new Error("ONNX runtime not loaded");
         const onnxPath = modelOnnxPath(this.modelId);
         const configPath = modelConfigPath(this.modelId);
-        if (!existsSync23(onnxPath) || !existsSync23(configPath)) {
+        if (!existsSync24(onnxPath) || !existsSync24(configPath)) {
           throw new Error(`Model files not found for ${this.modelId}`);
         }
-        this.config = JSON.parse(readFileSync16(configPath, "utf8"));
+        this.config = JSON.parse(readFileSync17(configPath, "utf8"));
         renderInfo("Loading voice model...");
         this.session = await this.ort.InferenceSession.create(onnxPath, {
           executionProviders: ["cpu"],
@@ -21371,10 +22647,10 @@ var init_stream_renderer = __esm({
 
 // packages/cli/dist/tui/edit-history.js
 import { appendFileSync, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join30 } from "node:path";
+import { join as join34 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
-  const historyDir = join30(repoRoot, ".oa", "history");
-  const logPath = join30(historyDir, "edits.jsonl");
+  const historyDir = join34(repoRoot, ".oa", "history");
+  const logPath = join34(historyDir, "edits.jsonl");
   try {
     mkdirSync10(historyDir, { recursive: true });
   } catch {
@@ -21485,9 +22761,9 @@ var init_edit_history = __esm({
 });
 
 // packages/cli/dist/tui/dream-engine.js
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10, readFileSync as readFileSync17, existsSync as existsSync24, cpSync, rmSync, readdirSync as readdirSync10 } from "node:fs";
-import { join as join31, basename as basename12 } from "node:path";
-import { execSync as execSync19 } from "node:child_process";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10, readFileSync as readFileSync18, existsSync as existsSync25, cpSync, rmSync, readdirSync as readdirSync10 } from "node:fs";
+import { join as join35, basename as basename12 } from "node:path";
+import { execSync as execSync21 } from "node:child_process";
 function adaptTool(tool) {
   return {
     name: tool.name,
@@ -21661,12 +22937,12 @@ var init_dream_engine = __esm({
         const content = String(args["content"] ?? "");
         if (!rawPath)
           return { success: false, output: "", error: "path is required", durationMs: Date.now() - start };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join31(this.dreamsDir, basename12(rawPath)) : join31(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join35(this.dreamsDir, basename12(rawPath)) : join35(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: writes are confined to .oa/dreams/", durationMs: Date.now() - start };
         }
         try {
-          const dir = join31(targetPath, "..");
+          const dir = join35(targetPath, "..");
           mkdirSync11(dir, { recursive: true });
           writeFileSync10(targetPath, content, "utf-8");
           return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start };
@@ -21696,15 +22972,15 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join31(this.dreamsDir, basename12(rawPath)) : join31(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join35(this.dreamsDir, basename12(rawPath)) : join35(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: edits are confined to .oa/dreams/", durationMs: Date.now() - start };
         }
         try {
-          if (!existsSync24(targetPath)) {
+          if (!existsSync25(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
-          let content = readFileSync17(targetPath, "utf-8");
+          let content = readFileSync18(targetPath, "utf-8");
           if (!content.includes(oldStr)) {
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start };
           }
@@ -21740,7 +23016,7 @@ var init_dream_engine = __esm({
           }
         }
         try {
-          const output = execSync19(cmd, {
+          const output = execSync21(cmd, {
             cwd: this.repoRoot,
             timeout: 3e4,
             encoding: "utf-8",
@@ -21763,7 +23039,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join31(repoRoot, ".oa", "dreams");
+        this.dreamsDir = join35(repoRoot, ".oa", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -21835,7 +23111,7 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join31(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              const summaryPath = join35(this.dreamsDir, `cycle-${cycle}-summary.md`);
               writeFileSync10(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
@@ -21958,29 +23234,29 @@ Dreams directory: ${this.dreamsDir}`);
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir = join31(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir = join35(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
           mkdirSync11(checkpointDir, { recursive: true });
           try {
-            const gitStatus = execSync19("git status --porcelain", {
+            const gitStatus = execSync21("git status --porcelain", {
               cwd: this.repoRoot,
               encoding: "utf-8",
               timeout: 1e4
             });
-            const gitDiff = execSync19("git diff", {
+            const gitDiff = execSync21("git diff", {
               cwd: this.repoRoot,
               encoding: "utf-8",
               timeout: 1e4
             });
-            const gitHash = execSync19("git rev-parse HEAD 2>/dev/null || echo 'no-git'", {
+            const gitHash = execSync21("git rev-parse HEAD 2>/dev/null || echo 'no-git'", {
               cwd: this.repoRoot,
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync10(join31(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync10(join31(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync10(join31(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync10(join31(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync10(join35(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync10(join35(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync10(join35(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync10(join35(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -21988,7 +23264,7 @@ Dreams directory: ${this.dreamsDir}`);
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync10(join31(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync10(join35(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (no git)`);
           }
         } catch (err) {
@@ -22046,14 +23322,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync10(join31(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync10(join35(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync10(join31(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync10(join35(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -23109,11 +24385,11 @@ var init_status_bar = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve20, join as join32, dirname as dirname10, extname as extname9 } from "node:path";
+import { resolve as resolve23, join as join36, dirname as dirname11, extname as extname9 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
-import { fileURLToPath as fileURLToPath7 } from "node:url";
-import { readFileSync as readFileSync18, rmSync as rmSync2 } from "node:fs";
-import { existsSync as existsSync25 } from "node:fs";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
+import { readFileSync as readFileSync19, rmSync as rmSync2 } from "node:fs";
+import { existsSync as existsSync26 } from "node:fs";
 function formatTimeAgo(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
   if (seconds < 60)
@@ -23130,14 +24406,14 @@ function formatTimeAgo(date) {
 function getVersion() {
   try {
     const require2 = createRequire2(import.meta.url);
-    const thisDir = dirname10(fileURLToPath7(import.meta.url));
+    const thisDir = dirname11(fileURLToPath8(import.meta.url));
     const candidates = [
-      join32(thisDir, "..", "package.json"),
-      join32(thisDir, "..", "..", "package.json"),
-      join32(thisDir, "..", "..", "..", "package.json")
+      join36(thisDir, "..", "package.json"),
+      join36(thisDir, "..", "..", "package.json"),
+      join36(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync25(pkgPath)) {
+      if (existsSync26(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -23235,7 +24511,13 @@ function buildTools(repoRoot, config, contextWindowSize) {
     new OcrPdfTool(repoRoot),
     new PdfToTextTool(repoRoot),
     // Advanced image OCR (multi-variant preprocessing pipeline)
-    new OcrImageAdvancedTool(repoRoot)
+    new OcrImageAdvancedTool(repoRoot),
+    // Browser automation (headless Chrome via Hydra scrape service)
+    new BrowserActionTool(),
+    // Temporal agency (scheduling, reminders, attention steering)
+    new SchedulerTool(repoRoot),
+    new ReminderTool(repoRoot),
+    new AgendaTool(repoRoot)
   ];
   return [
     ...executionTools.map(adaptTool2),
@@ -23648,7 +24930,7 @@ ${entry.fullContent}`
   } };
 }
 async function startInteractive(config, repoPath) {
-  const repoRoot = resolve20(repoPath ?? cwd());
+  const repoRoot = resolve23(repoPath ?? cwd());
   const resumeFlag = process.env.__OA_RESUMED ?? "";
   const isResumed = resumeFlag !== "";
   const hasTaskToResume = resumeFlag === "1";
@@ -23801,14 +25083,14 @@ async function startInteractive(config, repoPath) {
       renderInfo(msg);
       statusBar.endContentWrite();
     }
-  }, () => new Promise((resolve23) => {
+  }, () => new Promise((resolve26) => {
     depSudoPromptPending = true;
     depSudoResolver = (pw) => {
       depSudoPromptPending = false;
       depSudoResolver = null;
       if (pw)
         sessionSudoPassword = pw;
-      resolve23(pw);
+      resolve26(pw);
     };
     if (statusBar?.isActive) {
       statusBar.beginContentWrite();
@@ -24230,8 +25512,8 @@ async function startInteractive(config, repoPath) {
       return true;
     },
     destroyProject() {
-      const oaPath = join32(repoRoot, OA_DIR);
-      if (existsSync25(oaPath)) {
+      const oaPath = join36(repoRoot, OA_DIR);
+      if (existsSync26(oaPath)) {
         try {
           rmSync2(oaPath, { recursive: true, force: true });
           writeContent(() => renderInfo(`Removed ${OA_DIR}/ directory.`));
@@ -24293,6 +25575,41 @@ async function startInteractive(config, repoPath) {
       }, 150);
     }
   }
+  if (!isResumed) {
+    (async () => {
+      try {
+        const [dueReminders, activeAttention] = await Promise.all([
+          getDueReminders(repoRoot),
+          getActiveAttentionItems(repoRoot)
+        ]);
+        const criticalReminders = dueReminders.filter((r) => r.priority === "critical" || r.priority === "high");
+        const criticalAttention = activeAttention.filter((a) => a.priority === "critical" || a.priority === "high");
+        const totalDue = dueReminders.length + activeAttention.length;
+        if (totalDue > 0) {
+          setTimeout(() => {
+            writeContent(() => {
+              if (criticalReminders.length > 0 || criticalAttention.length > 0) {
+                renderWarning(`${criticalReminders.length + criticalAttention.length} urgent item(s) need attention`);
+                for (const r of criticalReminders)
+                  renderWarning(`  Reminder: ${r.message.slice(0, 80)}`);
+                for (const a of criticalAttention)
+                  renderWarning(`  ${a.category}: ${a.title}`);
+              }
+              if (totalDue > criticalReminders.length + criticalAttention.length) {
+                const normalCount = totalDue - criticalReminders.length - criticalAttention.length;
+                renderInfo(`${normalCount} pending agenda item(s). Use agenda() to view.`);
+              }
+            });
+            showPrompt();
+          }, 300);
+          if (dueReminders.length > 0) {
+            await markRemindersSeen(repoRoot, dueReminders.map((r) => r.id));
+          }
+        }
+      } catch {
+      }
+    })();
+  }
   if (hasTaskToResume) {
     const pendingTask = loadPendingTask(repoRoot);
     if (pendingTask) {
@@ -24463,13 +25780,13 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync25(resolve20(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync25(resolve20(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync26(resolve23(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync26(resolve23(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
-          const imgPath = resolve20(repoRoot, cleanPath);
-          const imgBuffer = readFileSync18(imgPath);
+          const imgPath = resolve23(repoRoot, cleanPath);
+          const imgBuffer = readFileSync19(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname9(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
@@ -24482,7 +25799,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
       } else if (isMedia) {
         writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
         const engine = getListenEngine();
-        const result = await engine.transcribeFile(resolve20(repoRoot, cleanPath), repoRoot);
+        const result = await engine.transcribeFile(resolve23(repoRoot, cleanPath), repoRoot);
         if (result) {
           const transcript = `[Transcription of ${cleanPath}]
 ${result.text}`;
@@ -24515,7 +25832,7 @@ ${result.text}`;
     if (isMedia && fullInput === input) {
       writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
       const engine = getListenEngine();
-      const result = await engine.transcribeFile(resolve20(repoRoot, cleanPath), repoRoot);
+      const result = await engine.transcribeFile(resolve23(repoRoot, cleanPath), repoRoot);
       if (result) {
         fullInput = `The user has provided an audio/video file: ${cleanPath}.
 
@@ -24646,7 +25963,7 @@ ${c2.dim("(Use /quit to exit)")}
   });
 }
 async function runWithTUI(task, config, repoPath) {
-  const repoRoot = resolve20(repoPath ?? cwd());
+  const repoRoot = resolve23(repoPath ?? cwd());
   const needsSetup = isFirstRun() || !await isModelAvailable(config);
   if (needsSetup && config.backendType === "ollama") {
     const setupModel = await runSetupWizard(config);
@@ -24750,9 +26067,9 @@ var init_run = __esm({
 // packages/indexer/dist/codebase-indexer.js
 import { glob } from "glob";
 import ignore from "ignore";
-import { readFile as readFile11, stat as stat4 } from "node:fs/promises";
+import { readFile as readFile14, stat as stat4 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join33, relative as relative3, extname as extname10, basename as basename13 } from "node:path";
+import { join as join37, relative as relative3, extname as extname10, basename as basename13 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -24796,7 +26113,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile11(join33(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile14(join37(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -24811,12 +26128,12 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join33(this.config.rootDir, relativePath);
+          const fullPath = join37(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
               continue;
-            const content = await readFile11(fullPath);
+            const content = await readFile14(fullPath);
             const hash = createHash("sha256").update(content).digest("hex");
             const ext = extname10(relativePath);
             indexed.push({
@@ -24857,7 +26174,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join33(current.path, part),
+                  path: join37(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -24939,14 +26256,14 @@ var index_repo_exports = {};
 __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
-import { resolve as resolve21 } from "node:path";
-import { existsSync as existsSync26, statSync as statSync10 } from "node:fs";
+import { resolve as resolve24 } from "node:path";
+import { existsSync as existsSync27, statSync as statSync10 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
-  const repoRoot = resolve21(opts.repoPath ?? cwd2());
+  const repoRoot = resolve24(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync26(repoRoot)) {
+  if (!existsSync27(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -25198,7 +26515,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join34, resolve as resolve22 } from "node:path";
+import { join as join38, resolve as resolve25 } from "node:path";
 import { homedir as homedir13 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value) {
@@ -25225,7 +26542,7 @@ async function configCommand(opts, config) {
   return handleShow(opts, config);
 }
 function handleShow(opts, config) {
-  const repoRoot = resolve22(opts.repoPath ?? cwd3());
+  const repoRoot = resolve25(opts.repoPath ?? cwd3());
   printHeader("Configuration");
   printSection("Active Settings (merged)");
   printKeyValue("backendUrl", config.backendUrl, 2);
@@ -25257,7 +26574,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join34(homedir13(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join38(homedir13(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -25290,13 +26607,13 @@ function handleSet(opts, _config) {
     process.exit(1);
   }
   if (opts.local) {
-    const repoRoot = resolve22(opts.repoPath ?? cwd3());
+    const repoRoot = resolve25(opts.repoPath ?? cwd3());
     try {
       initOaDirectory(repoRoot);
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${redactIfSensitive(key, value)}`);
-      printInfo(`Saved to ${join34(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join38(repoRoot, ".oa", "settings.json")}`);
       printInfo("This override applies only when running in this workspace.");
     } catch (err) {
       printError(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
@@ -25357,7 +26674,7 @@ var serve_exports = {};
 __export(serve_exports, {
   serveCommand: () => serveCommand
 });
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 async function serveCommand(opts, config) {
   const backendType = config.backendType;
   if (backendType === "ollama") {
@@ -25449,8 +26766,8 @@ async function serveVllm(opts, config) {
   await runVllmServer(args, opts.verbose ?? false);
 }
 async function runVllmServer(args, verbose) {
-  return new Promise((resolve23, reject) => {
-    const child = spawn9("python", args, {
+  return new Promise((resolve26, reject) => {
+    const child = spawn10("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
     });
@@ -25484,10 +26801,10 @@ async function runVllmServer(args, verbose) {
     child.once("exit", (code, signal) => {
       if (signal) {
         printInfo(`vLLM server stopped by signal ${signal}`);
-        resolve23();
+        resolve26();
       } else if (code === 0) {
         printSuccess("vLLM server exited cleanly");
-        resolve23();
+        resolve26();
       } else {
         printError(`vLLM server exited with code ${code}`);
         reject(new Error(`vLLM exited with code ${code}`));
@@ -25516,7 +26833,7 @@ __export(eval_exports, {
 });
 import { tmpdir as tmpdir7 } from "node:os";
 import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join35 } from "node:path";
+import { join as join39 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -25637,9 +26954,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join35(tmpdir7(), `open-agents-eval-${Date.now()}`);
+  const dir = join39(tmpdir7(), `open-agents-eval-${Date.now()}`);
   mkdirSync12(dir, { recursive: true });
-  writeFileSync11(join35(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  writeFileSync11(join39(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -25698,8 +27015,8 @@ init_output();
 init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
-import { fileURLToPath as fileURLToPath8 } from "node:url";
-import { dirname as dirname11, join as join36 } from "node:path";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
+import { dirname as dirname12, join as join40 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -25806,7 +27123,7 @@ init_output();
 function getVersion2() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join36(dirname11(fileURLToPath8(import.meta.url)), "..", "package.json");
+    const pkgPath = join40(dirname12(fileURLToPath9(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {