0agent 1.0.67 → 1.0.69

package/dist/daemon.mjs

@@ -1507,7 +1507,7 @@ var init_EdgeWeightUpdater = __esm({
         this.weightLog.append(event);
       }
       sleep(ms) {
-        return new Promise((resolve16) => setTimeout(resolve16, ms));
+        return new Promise((resolve17) => setTimeout(resolve17, ms));
       }
     };
   }
@@ -3007,11 +3007,934 @@ var init_MemoryCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/OpenInterpreterCapability.ts
-import { spawn as spawn3 } from "node:child_process";
+// packages/daemon/src/capabilities/GUICapability.ts
+import { spawn as spawn3, spawnSync as spawnSync4 } from "node:child_process";
 import { writeFileSync as writeFileSync2, unlinkSync } from "node:fs";
 import { resolve as resolve3 } from "node:path";
-import { tmpdir } from "node:os";
+import { tmpdir, platform as platform2 } from "node:os";
+var GUICapability;
+var init_GUICapability = __esm({
+  "packages/daemon/src/capabilities/GUICapability.ts"() {
+    "use strict";
+    GUICapability = class {
+      name = "gui_automation";
+      description = "Automate desktop GUI \u2014 click, type, screenshot, hotkeys, find text on screen.";
+      toolDefinition = {
+        name: "gui_automation",
+        description: "GUI automation + comprehensive browser control. BROWSER (no Screen Recording needed): click_text \u2014 click any element by its visible text; type_in \u2014 fill a form field by placeholder/label; get_elements \u2014 list all interactive elements on the page; read_element \u2014 read text of an element by CSS selector; get_media_state \u2014 check if video is playing/paused/current time; scroll_to \u2014 scroll page or scroll to specific element; exec_js \u2014 run arbitrary JavaScript in Chrome tab; browser_state \u2014 get current URL + title; cdp_screenshot \u2014 screenshot via CDP (needs --remote-debugging-port=9222) with OCR. NATIVE APPS: accessibility_click \u2014 click button in macOS app (WhatsApp, Finder) via Accessibility API. NAVIGATION: open_url \u2014 navigate Chrome tab, returns URL+title+video state. MOUSE/KEYBOARD: click, type, hotkey (use app param to target Chrome vs Terminal), screenshot (needs Screen Recording).",
+        input_schema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              description: 'Browser (no Screen Recording): "click_text"|"type_in"|"get_elements"|"read_element"|"get_media_state"|"scroll_to"|"exec_js"|"browser_state"|"cdp_screenshot" | Native apps: "accessibility_click" | Navigation: "open_url"|"open_app" | Mouse/KB (Screen Recording for screenshots): "screenshot"|"click"|"double_click"|"right_click"|"move"|"type"|"hotkey"|"scroll"|"drag"|"find_and_click"|"get_screen_size"|"get_cursor_pos"|"wait"'
+            },
+            js: { type: "string", description: `JavaScript to execute in Chrome tab (use with exec_js). Example: "document.querySelector('video').paused"` },
+            selector: { type: "string", description: 'CSS selector for read_element, type_in, scroll_to (e.g. "input[type=search]", ".title", "video")' },
+            x: { type: "number", description: "X coordinate (pixels from left)" },
+            y: { type: "number", description: "Y coordinate (pixels from top)" },
+            to_x: { type: "number", description: "End X for drag" },
+            to_y: { type: "number", description: "End Y for drag" },
+            text: { type: "string", description: "Text to type, or text to search for (find_and_click)" },
+            keys: { type: "string", description: 'Hotkey combo e.g. "cmd+c", "ctrl+z", "alt+tab", "enter"' },
+            direction: { type: "string", description: '"up" | "down" | "left" | "right" for scroll' },
+            amount: { type: "number", description: "Scroll clicks (default 3)" },
+            app: { type: "string", description: 'App name to open e.g. "Safari", "Terminal", "Chrome"' },
+            url: { type: "string", description: 'URL to open e.g. "https://example.com" (use with open_url)' },
+            seconds: { type: "number", description: "Seconds to wait (use with wait action, default 2)" },
+            interval: { type: "number", description: "Seconds to wait between actions (default 0.05)" },
+            duration: { type: "number", description: "Seconds for mouse movement animation (default 0.2)" }
+          },
+          required: ["action"]
+        }
+      };
+      async execute(input, _cwd, signal) {
+        const action = String(input.action ?? "").toLowerCase().trim();
+        const start = Date.now();
+        const script = this._buildScript(action, input);
+        if (!script) {
+          return { success: false, output: `Unknown GUI action: "${action}". Valid: screenshot, click, double_click, right_click, move, type, hotkey, scroll, drag, find_and_click, get_screen_size, get_cursor_pos, wait, open_url, open_app, exec_js, browser_state`, duration_ms: 0 };
+        }
+        if (signal?.aborted) {
+          return { success: false, output: "Cancelled.", duration_ms: 0 };
+        }
+        const tmpFile = resolve3(tmpdir(), `0agent_gui_${Date.now()}.py`);
+        writeFileSync2(tmpFile, script, "utf8");
+        const runPy = (file) => new Promise((res) => {
+          const proc = spawn3("python3", [file], { env: process.env });
+          const out = [];
+          const err = [];
+          let settled = false;
+          const finish = (code) => {
+            if (settled) return;
+            settled = true;
+            signal?.removeEventListener("abort", onAbort);
+            clearTimeout(timer);
+            res({ stdout: out.join(""), stderr: err.join(""), code });
+          };
+          const onAbort = () => {
+            try {
+              proc.kill("SIGKILL");
+            } catch {
+            }
+            finish(null);
+          };
+          signal?.addEventListener("abort", onAbort, { once: true });
+          proc.stdout.on("data", (d) => out.push(d.toString()));
+          proc.stderr.on("data", (d) => err.push(d.toString()));
+          proc.on("exit", finish);
+          proc.on("error", () => finish(-1));
+          const timer = setTimeout(() => {
+            try {
+              proc.kill("SIGKILL");
+            } catch {
+            }
+            finish(null);
+          }, 3e4);
+        });
+        let result = await runPy(tmpFile);
+        try {
+          unlinkSync(tmpFile);
+        } catch {
+        }
+        if (signal?.aborted) {
+          return { success: false, output: "Cancelled.", duration_ms: Date.now() - start };
+        }
+        if (result.code !== 0 && result.code !== null) {
+          const err = result.stderr.trim();
+          if (err.includes("No module named") || err.includes("ModuleNotFoundError")) {
+            const missing = err.includes("pyautogui") ? "pyautogui pillow pytesseract" : err.includes("PIL") ? "pillow" : err.includes("tesseract") ? "pytesseract" : "pyautogui pillow";
+            const install = spawnSync4("pip3", ["install", ...missing.split(" "), "-q"], {
+              timeout: 6e4,
+              encoding: "utf8"
+            });
+            if (install.status !== 0) {
+              return { success: false, output: `Auto-install failed: ${install.stderr?.slice(0, 200)}. Run: pip3 install ${missing}`, duration_ms: Date.now() - start };
+            }
+            writeFileSync2(tmpFile, script, "utf8");
+            result = await runPy(tmpFile);
+            try {
+              unlinkSync(tmpFile);
+            } catch {
+            }
+            if (signal?.aborted) return { success: false, output: "Cancelled.", duration_ms: Date.now() - start };
+            if (result.code === 0) return { success: true, output: result.stdout.trim() || "Done", duration_ms: Date.now() - start };
+            return { success: false, output: result.stderr.trim() || "Unknown error after install", duration_ms: Date.now() - start };
+          }
+          const isScreenRecordingDenied = err.includes("could not create image from display") || err.includes("screen capture failed") || err.includes("screencapture") || err.includes("CGDisplayStream") || err.includes("Operation not permitted") || err.includes("OSError") && err.includes("display") || result.stdout.includes("could not create image from display");
+          if (isScreenRecordingDenied) {
+            if (platform2() === "darwin") {
+              spawnSync4("open", ["x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture"], { timeout: 3e3 });
+              const fallbackScript = `
+import subprocess
+as_script = '''tell application "Google Chrome"
+  tell front window
+    tell active tab
+      set tabURL to URL
+      set tabTitle to title
+      set videoSt to execute javascript "try{let v=document.querySelector('video');v?(v.paused?'PAUSED':'PLAYING:'+v.currentTime.toFixed(1)+'s'):'no-video'}catch(e){'?'}"
+      return tabURL & "|||" & tabTitle & "|||" & videoSt
+    end tell
+  end tell
+end tell'''
+r = subprocess.run(['osascript', '-e', as_script], capture_output=True, text=True)
+out = r.stdout.strip()
+parts = out.split('|||') if '|||' in out else []
+if len(parts) >= 3:
+    print(f"[No screenshot \u2014 Screen Recording permission needed]")
+    print(f"Browser URL: {parts[0]}")
+    print(f"Page title:  {parts[1]}")
+    print(f"Video state: {parts[2]}")
+    print(f"To enable screenshots: System Settings \u2192 Privacy & Security \u2192 Screen Recording \u2192 enable Terminal")
+else:
+    print("[No screenshot \u2014 Screen Recording permission needed]")
+    print("To fix: System Settings \u2192 Privacy & Security \u2192 Screen Recording \u2192 enable Terminal (or iTerm2)")
+`;
+              const fallbackTmp = resolve3(tmpdir(), `0agent_scfb_${Date.now()}.py`);
+              writeFileSync2(fallbackTmp, fallbackScript, "utf8");
+              const fbResult = await runPy(fallbackTmp);
+              try {
+                unlinkSync(fallbackTmp);
+              } catch {
+              }
+              if (fbResult.code === 0 && fbResult.stdout.trim()) {
+                return { success: false, output: fbResult.stdout.trim(), duration_ms: Date.now() - start };
+              }
+            }
+            return {
+              success: false,
+              output: 'macOS Screen Recording permission required for screenshots.\nSystem Settings opened \u2192 Privacy & Security \u2192 Screen Recording \u2192 enable Terminal/iTerm2.\nFor browser content, use exec_js instead: {action:"exec_js",js:"document.title"} or {action:"browser_state"} \u2014 these work without Screen Recording.',
+              duration_ms: Date.now() - start
+            };
+          }
+          if (err.includes("accessibility") || err.includes("permission") || err.includes("AXIsProcessTrusted")) {
+            if (platform2() === "darwin") {
+              spawnSync4("open", ["x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility"], { timeout: 3e3 });
+            }
+            return {
+              success: false,
+              output: "macOS Accessibility permission required for GUI automation.\n\u2192 System Settings has been opened automatically.\n\u2192 Go to: Privacy & Security \u2192 Accessibility \u2192 enable Terminal (or iTerm2 / the app running 0agent)\n\u2192 Then re-run your task.",
+              duration_ms: Date.now() - start
+            };
+          }
+          return { success: false, output: `GUI error: ${err.slice(0, 300)}`, duration_ms: Date.now() - start };
+        }
+        return { success: true, output: result.stdout.trim() || "Done", duration_ms: Date.now() - start };
+      }
+      _buildScript(action, input) {
+        const x = input.x != null ? Number(input.x) : null;
+        const y = input.y != null ? Number(input.y) : null;
+        const toX = input.to_x != null ? Number(input.to_x) : null;
+        const toY = input.to_y != null ? Number(input.to_y) : null;
+        const text = input.text != null ? String(input.text) : "";
+        const keys = input.keys != null ? String(input.keys) : "";
+        const dir = input.direction != null ? String(input.direction) : "down";
+        const amount = input.amount != null ? Number(input.amount) : 3;
+        const app = input.app != null ? String(input.app) : "";
+        const url = input.url != null ? String(input.url) : "";
+        const seconds = input.seconds != null ? Number(input.seconds) : 2;
+        const interval = input.interval != null ? Number(input.interval) : 0.05;
+        const duration = input.duration != null ? Number(input.duration) : 0.2;
+        const header = `
+import pyautogui
+import time
+import sys
+pyautogui.FAILSAFE = False
+pyautogui.PAUSE = ${interval}
+`;
+        switch (action) {
+          case "get_screen_size":
+            return header + `
+w, h = pyautogui.size()
+print(f"Screen size: {w} x {h}")
+`;
+          case "get_cursor_pos":
+            return header + `
+x, y = pyautogui.position()
+print(f"Cursor position: ({x}, {y})")
+`;
+          case "wait":
+            return header + `
+time.sleep(${seconds})
+print(f"Waited ${seconds}s")
+`;
+          case "screenshot": {
+            return header + `
+import os, tempfile
+from PIL import Image
+
+# Take screenshot
+shot_path = os.path.join(tempfile.gettempdir(), "0agent_screen.png")
+img = pyautogui.screenshot(shot_path)
+
+w, h = img.size
+print(f"Screen: {w}x{h}")
+
+# Try OCR with pytesseract
+try:
+    import pytesseract
+    # Resize for faster OCR if screen is large
+    scale = min(1.0, 1920 / w)
+    small = img.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
+    text = pytesseract.image_to_string(small, config='--psm 11')
+    lines = [l.strip() for l in text.splitlines() if l.strip()]
+    print("\\nOn-screen text (OCR):")
+    print("\\n".join(lines[:80]))
+
+    # Also get bounding boxes for clickable text
+    data = pytesseract.image_to_data(small, output_type=pytesseract.Output.DICT)
+    hits = []
+    for i, word in enumerate(data['text']):
+        if word.strip() and int(data['conf'][i]) > 50:
+            bx = int(data['left'][i] / scale)
+            by = int(data['top'][i] / scale)
+            bw = int(data['width'][i] / scale)
+            bh = int(data['height'][i] / scale)
+            hits.append(f"  '{word}' at ({bx + bw//2}, {by + bh//2})")
+    if hits:
+        print("\\nClickable words with center coordinates:")
+        print("\\n".join(hits[:40]))
+except ImportError:
+    print("(pytesseract not installed \u2014 install it for OCR: pip3 install pytesseract)")
+except Exception as e:
+    print(f"OCR failed: {e}")
+finally:
+    try:
+        os.remove(shot_path)
+    except Exception:
+        pass
+`;
+          }
+          case "click":
+            if (x == null || y == null) return null;
+            return header + `
+pyautogui.click(${x}, ${y}, duration=${duration})
+print(f"Clicked at ({${x}}, {${y}})")
+`;
+          case "double_click":
+            if (x == null || y == null) return null;
+            return header + `
+pyautogui.doubleClick(${x}, ${y}, duration=${duration})
+print(f"Double-clicked at ({${x}}, {${y}})")
+`;
+          case "right_click":
+            if (x == null || y == null) return null;
+            return header + `
+pyautogui.rightClick(${x}, ${y}, duration=${duration})
+print(f"Right-clicked at ({${x}}, {${y}})")
+`;
+          case "move":
+            if (x == null || y == null) return null;
+            return header + `
+pyautogui.moveTo(${x}, ${y}, duration=${duration})
+print(f"Moved to ({${x}}, {${y}})")
+`;
+          case "type": {
+            if (!text) return null;
+            return header + `
+pyautogui.write(${JSON.stringify(text)}, interval=${interval})
+print("Typed successfully")
+`;
+          }
+          case "hotkey": {
+            if (!keys) return null;
+            const targetApp = input.app ? String(input.app) : "";
+            const parts = keys.toLowerCase().replace(/cmd|command|meta/g, "command").replace(/ctrl|control/g, "ctrl").replace(/opt|option/g, "option").split(/[+\-]/).map((k) => k.trim()).filter(Boolean);
+            const pyKeys = JSON.stringify(parts);
+            if (targetApp && platform2() === "darwin") {
+              const safeApp = targetApp.replace(/'/g, "\\'");
+              const asKey = parts[parts.length - 1] ?? "";
+              const modifiers = parts.slice(0, -1).map((k) => {
+                if (k === "command") return "command down";
+                if (k === "ctrl") return "control down";
+                if (k === "shift") return "shift down";
+                if (k === "option") return "option down";
+                return "";
+              }).filter(Boolean).join(", ");
+              const asModStr = modifiers ? ` using {${modifiers}}` : "";
+              return header + `
+import subprocess, time
+# Focus target app first
+subprocess.run(['osascript', '-e', 'tell application "${safeApp}" to activate'], capture_output=True)
+time.sleep(0.3)
+# Send keystroke via AppleScript (reliable \u2014 goes to the focused app, not Terminal)
+as_script = '''tell application "System Events"
+  keystroke "${asKey}"${asModStr}
+end tell'''
+r = subprocess.run(['osascript', '-e', as_script], capture_output=True, text=True)
+if r.returncode == 0:
+    print(f"Sent ${parts.join("+")} to ${safeApp}")
+else:
+    print(f"Keystroke error: {r.stderr.strip()[:200]}")
+`;
+            }
+            return header + `
+keys = ${pyKeys}
+pyautogui.hotkey(*keys)
+print(f"Pressed: {'+'.join(keys)}")
+`;
+          }
+          case "scroll": {
+            const clicksVal = dir === "up" ? amount : dir === "down" ? -amount : 0;
+            const hVal = dir === "left" ? -amount : dir === "right" ? amount : 0;
+            const sx = x ?? "pyautogui.size()[0]//2";
+            const sy = y ?? "pyautogui.size()[1]//2";
+            return header + `
+${hVal !== 0 ? `pyautogui.hscroll(${hVal}, x=${sx}, y=${sy})` : `pyautogui.scroll(${clicksVal}, x=${sx}, y=${sy})`}
+print(f"Scrolled ${dir} by ${amount}")
+`;
+          }
+          case "drag":
+            if (x == null || y == null || toX == null || toY == null) return null;
+            return header + `
+pyautogui.moveTo(${x}, ${y}, duration=${duration})
+pyautogui.dragTo(${toX}, ${toY}, duration=${duration * 2}, button='left')
+print(f"Dragged from ({${x}},{${y}}) to ({${toX}},{${toY}})")
+`;
+          case "find_and_click": {
+            if (!text) return null;
+            const safeText = text.replace(/'/g, "\\'");
+            return header + `
+from PIL import Image
+import pytesseract, os, tempfile
+
+shot_path = os.path.join(tempfile.gettempdir(), "0agent_screen.png")
+img = pyautogui.screenshot(shot_path)
+w, h = img.size
+
+data = pytesseract.image_to_data(img, output_type=pytesseract.Output.DICT)
+target = '${safeText}'.lower()
+found = []
+for i, word in enumerate(data['text']):
+    if target in word.lower() and int(data['conf'][i]) > 40:
+        cx = data['left'][i] + data['width'][i] // 2
+        cy = data['top'][i] + data['height'][i] // 2
+        found.append((cx, cy, word))
+
+if found:
+    cx, cy, word = found[0]
+    pyautogui.click(cx, cy, duration=${duration})
+    print(f"Found '{word}' at ({cx},{cy}) \u2014 clicked")
+else:
+    # Retry once after a brief wait (element may still be loading)
+    time.sleep(1.5)
+    img2 = pyautogui.screenshot()
+    data2 = pytesseract.image_to_data(img2, output_type=pytesseract.Output.DICT)
+    found2 = []
+    for i, word in enumerate(data2['text']):
+        if target in word.lower() and int(data2['conf'][i]) > 40:
+            cx2 = data2['left'][i] + data2['width'][i] // 2
+            cy2 = data2['top'][i] + data2['height'][i] // 2
+            found2.append((cx2, cy2, word))
+    if found2:
+        cx2, cy2, word2 = found2[0]
+        pyautogui.click(cx2, cy2, duration=${duration})
+        print(f"Found '{word2}' at ({cx2},{cy2}) after retry \u2014 clicked")
+    else:
+        print(f"Text '${safeText}' not found on screen after retry. Take a screenshot to see what changed.")
+        sys.exit(1)
+try:
+    os.remove(shot_path)
+except Exception:
+    pass
+`;
+          }
+          case "open_url": {
+            if (!url) return null;
+            let finalUrl = url;
+            if (/youtube\.com\/watch/i.test(url) && !url.includes("autoplay")) {
+              finalUrl = url + (url.includes("?") ? "&" : "?") + "autoplay=1";
+            }
+            const safeUrl = finalUrl.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+            const isYouTubeVideo = /youtube\.com\/watch/i.test(finalUrl);
+            const osName = platform2();
+            if (osName === "darwin") {
+              return header + `
+import subprocess
+import time
+
+url = '${safeUrl}'
+is_youtube_video = ${isYouTubeVideo ? "True" : "False"}
+
+# Check if Chrome is running
+chrome_running = subprocess.run(['pgrep', '-x', 'Google Chrome'], capture_output=True).returncode == 0
+firefox_running = subprocess.run(['pgrep', '-x', 'firefox'], capture_output=True).returncode == 0
+safari_running  = subprocess.run(['pgrep', '-x', 'Safari'], capture_output=True).returncode == 0
+
+import urllib.parse
+domain = urllib.parse.urlparse(url).netloc
+
+if chrome_running:
+    if is_youtube_video:
+        # Navigate the CURRENT active tab directly to avoid domain-matching a wrong/stale tab
+        nav_script = f"""tell application "Google Chrome"
+  tell front window
+    tell active tab
+      set URL to "{url}"
+    end tell
+  end tell
+  activate
+end tell"""
+        subprocess.run(['osascript', '-e', nav_script], capture_output=True)
+        time.sleep(3)
+        # Unmute + play via JS (handles autoplay policy blocks)
+        play_script = """tell application "Google Chrome"
+  tell front window
+    tell active tab
+      execute javascript "try{let v=document.querySelector('video');if(v){v.muted=false;v.volume=1.0;v.play();}}catch(e){}"
+    end tell
+  end tell
+end tell"""
+        subprocess.run(['osascript', '-e', play_script], capture_output=True)
+        time.sleep(1)
+        # Verify: get URL, title, video state \u2014 all via AppleScript, no Screen Recording needed
+        verify_script = """tell application "Google Chrome"
+  tell front window
+    tell active tab
+      set tabURL to URL
+      set tabTitle to title
+      set videoSt to execute javascript "try{let v=document.querySelector('video');v?(v.paused?'PAUSED':'PLAYING:'+v.currentTime.toFixed(1)+'s'):'no-video'}catch(e){'err'}"
+      return tabURL & "|||" & tabTitle & "|||" & videoSt
+    end tell
+  end tell
+end tell"""
+        vr = subprocess.run(['osascript', '-e', verify_script], capture_output=True, text=True)
+        parts = vr.stdout.strip().split('|||')
+        if len(parts) >= 3:
+            print(f"URL: {parts[0]}")
+            print(f"Title: {parts[1]}")
+            st = parts[2].strip()
+            if 'PLAYING' in st:
+                print(f"Video: {st} \u2713")
+            elif st == 'PAUSED':
+                # Send play() one more time
+                subprocess.run(['osascript', '-e', play_script], capture_output=True)
+                time.sleep(0.5)
+                print("Video: was PAUSED \u2014 sent play() again, should be playing now")
+            else:
+                print(f"Video state: {st} (page may still be loading)")
+        else:
+            print(f"Navigated to: {url}")
+            print(f"(Verification unavailable: {vr.stdout.strip() or vr.stderr.strip()[:100]})")
+    else:
+        # Non-video: switch to existing same-domain tab or open new tab
+        check_script = f"""tell application "Google Chrome"
+  set foundTab to false
+  repeat with w in every window
+    set tabIdx to 1
+    repeat with t in every tab of w
+      if URL of t contains "{domain}" then
+        set active tab index of w to tabIdx
+        set index of w to 1
+        set foundTab to true
+        exit repeat
+      end if
+      set tabIdx to tabIdx + 1
+    end repeat
+    if foundTab then exit repeat
+  end repeat
+  if foundTab then
+    activate
+    return "switched"
+  else
+    tell front window to make new tab with properties {{URL:"{url}"}}
+    activate
+    return "new-tab"
+  end if
+end tell"""
+        r = subprocess.run(['osascript', '-e', check_script], capture_output=True, text=True)
+        switched = r.stdout.strip() == "switched"
+        # Verify actual URL and title loaded (catches wrong-domain tab issues)
+        state_script = """tell application "Google Chrome"
+  tell front window
+    tell active tab
+      return URL & "|||" & title
+    end tell
+  end tell
+end tell"""
+        sr = subprocess.run(['osascript', '-e', state_script], capture_output=True, text=True)
+        sp = sr.stdout.strip().split('|||')
+        if len(sp) >= 2:
+            print(f"{'Switched to' if switched else 'Opened'}: {sp[0]}")
+            print(f"Title: {sp[1]}")
+        else:
+            print(f"{'Switched to existing' if switched else 'Opened new'} Chrome tab: {url}")
+elif firefox_running:
+    script = f'tell application "Firefox" to open location "{url}"'
+    subprocess.run(['osascript', '-e', script])
+    subprocess.run(['osascript', '-e', 'tell application "Firefox" to activate'])
+    print(f"Navigated Firefox to: {url}")
+elif safari_running:
+    script = f'tell application "Safari" to open location "{url}"'
+    subprocess.run(['osascript', '-e', script])
+    subprocess.run(['osascript', '-e', 'tell application "Safari" to activate'])
+    print(f"Navigated Safari to: {url}")
+else:
+    # No browser open \u2014 launch default browser with the URL
+    subprocess.run(['open', url])
+    print(f"Launched browser with: {url}")
+time.sleep(1.0)
+`;
+            }
+            return header + `
+import subprocess
+
+url = '${safeUrl}'
+
+# Try to reuse existing browser via wmctrl/xdotool, fall back to xdg-open
+chrome_pid = subprocess.run(['pgrep', '-x', 'chrome'], capture_output=True)
+firefox_pid = subprocess.run(['pgrep', '-x', 'firefox'], capture_output=True)
+
+if chrome_pid.returncode == 0:
+    subprocess.Popen(['google-chrome', '--new-tab', url])
+    print(f"Opened in Chrome tab: {url}")
+elif firefox_pid.returncode == 0:
+    subprocess.Popen(['firefox', '--new-tab', url])
+    print(f"Opened in Firefox tab: {url}")
+else:
+    subprocess.Popen(['xdg-open', url])
+    print(f"Opened with default browser: {url}")
+time.sleep(1.0)
+`;
+          }
+          case "open_app": {
+            if (!app) return null;
+            const safeApp = app.replace(/'/g, "\\'");
+            const os = platform2();
+            if (os === "darwin") {
+              return header + `
+import subprocess
+result = subprocess.run(['open', '-a', '${safeApp}'], capture_output=True, text=True)
+if result.returncode == 0:
+    print(f"Opened: ${safeApp}")
+    time.sleep(1.5)  # wait for app to launch
+else:
+    # Try spotlight
+    pyautogui.hotkey('command', 'space')
+    time.sleep(0.5)
+    pyautogui.write('${safeApp}', interval=0.05)
+    time.sleep(0.5)
+    pyautogui.press('enter')
+    print(f"Opened via Spotlight: ${safeApp}")
+    time.sleep(1.5)
+`;
+            }
+            return header + `
+import subprocess
+subprocess.Popen(['${safeApp}'])
+print(f"Launched: ${safeApp}")
+time.sleep(1.5)
+`;
+          }
+          // ── New high-level browser actions — no Screen Recording needed ───────────
+          case "click_text": {
+            if (!text) return null;
+            if (platform2() !== "darwin") return header + `print("click_text requires macOS + Chrome")`;
+            return this._chromeJs(JSON.stringify(text), `
+(function(t) {
+  t = t.toLowerCase().trim();
+  // Pass 1: interactive elements (buttons, links, roles)
+  var candidates = Array.from(document.querySelectorAll(
+    'button,a,[role="button"],[role="link"],[role="menuitem"],[role="option"],[role="tab"],[tabindex="0"],label'
+  ));
+  var match = candidates.find(el => {
+    var txt = (el.textContent || el.getAttribute('aria-label') || el.getAttribute('title') || '').trim().toLowerCase();
+    return txt === t || txt.startsWith(t) || (t.length > 3 && txt.includes(t));
+  });
+  // Pass 2: any visible leaf element with matching text
+  if (!match) {
+    match = Array.from(document.querySelectorAll('*')).find(el => {
+      if (!el.offsetParent && el !== document.body) return false;
+      if (el.children.length > 0) return false;
+      var txt = (el.textContent || '').trim().toLowerCase();
+      return txt === t || (t.length > 4 && txt.includes(t) && txt.length < t.length * 3);
+    });
+  }
+  if (!match) return 'NOT_FOUND: ' + t;
+  match.scrollIntoView({behavior:'instant', block:'center'});
+  match.focus();
+  ['mousedown','mouseup','click'].forEach(e =>
+    match.dispatchEvent(new MouseEvent(e, {bubbles:true, cancelable:true}))
+  );
+  return 'CLICKED: ' + (match.textContent || match.getAttribute('aria-label') || match.tagName).trim().slice(0,80);
+})(JSARG)
+`);
+          }
+          case "type_in": {
+            if (!text) return null;
+            if (platform2() !== "darwin") return header + `print("type_in requires macOS + Chrome")`;
+            const query = String(input.selector ?? input.query ?? "").trim() || "active";
+            const args = JSON.stringify([query, text]);
+            return this._chromeJs(args, `
+(function(query, value) {
+  var el = query === 'active' ? document.activeElement :
+    document.querySelector('input[placeholder*="'+query+'" i]') ||
+    document.querySelector('input[aria-label*="'+query+'" i]') ||
+    document.querySelector('textarea[placeholder*="'+query+'" i]') ||
+    document.querySelector('[role="textbox"][aria-label*="'+query+'" i]') ||
+    document.querySelector('[contenteditable="true"]') ||
+    document.querySelector('input[type="text"],input[type="search"],input:not([type])');
+  if (!el) return 'NOT_FOUND: ' + query;
+  el.focus();
+  if (el.getAttribute('contenteditable') !== null) {
+    el.textContent = '';
+    document.execCommand('insertText', false, value);
+  } else {
+    var proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+    Object.getOwnPropertyDescriptor(proto, 'value').set.call(el, value);
+    ['input','change'].forEach(t => el.dispatchEvent(new Event(t, {bubbles:true})));
+  }
+  return 'TYPED "'+value.slice(0,40)+'" in '+(el.placeholder||el.getAttribute('aria-label')||el.tagName);
+})(JSARG[0], JSARG[1])
+`);
+          }
+          case "read_element": {
+            if (platform2() !== "darwin") return header + `print("read_element requires macOS + Chrome")`;
+            const sel = String(input.selector ?? "").trim();
+            return this._chromeJs(JSON.stringify(sel || "body"), `
+(function(sel) {
+  var el = sel ? document.querySelector(sel) : document.body;
+  if (!el) return 'NOT_FOUND: ' + sel;
+  return (el.textContent || el.innerText || el.value || '').trim().replace(/\\s+/g,' ').slice(0, 800);
+})(JSARG)
+`);
+          }
+          case "get_elements": {
+            if (platform2() !== "darwin") return header + `print("get_elements requires macOS + Chrome")`;
+            return this._chromeJs(JSON.stringify(""), `
+(function() {
+  var seen = new Set(), els = [];
+  document.querySelectorAll('button,a,input,select,textarea,[role="button"],[role="link"],[role="tab"],[role="option"],h1,h2,h3,video,audio').forEach(function(el,i) {
+    if (i > 80 || !el.offsetParent) return;
+    var label = (el.textContent || el.getAttribute('aria-label') || el.placeholder || el.getAttribute('title') || el.value || '').trim().slice(0,80);
+    if (!label || seen.has(label)) return;
+    seen.add(label);
+    els.push(el.tagName.toLowerCase()+': '+label);
+  });
+  return els.length ? els.join('\\n') : 'No interactive elements found';
+})()
+`);
+          }
+          case "get_media_state": {
+            if (platform2() !== "darwin") return header + `print("get_media_state requires macOS + Chrome")`;
+            return this._chromeJs(JSON.stringify(""), `
+(function() {
+  var v = document.querySelector('video,audio');
+  if (!v) return 'No media on this page';
+  return JSON.stringify({
+    state: v.paused ? 'PAUSED' : 'PLAYING',
+    time: v.currentTime.toFixed(1)+'s',
+    duration: isFinite(v.duration) ? v.duration.toFixed(1)+'s' : 'live/unknown',
+    muted: v.muted,
+    volume: Math.round(v.volume*100)+'%',
+    title: document.title.slice(0,80)
+  });
+})()
+`);
+          }
+          case "scroll_to": {
+            if (platform2() !== "darwin") return header + `print("scroll_to requires macOS + Chrome")`;
+            const sel = String(input.selector ?? "").trim();
+            const scrollDir = String(input.direction ?? "down").toLowerCase();
+            const scrollAmt = input.amount != null ? Number(input.amount) : 400;
+            if (sel) {
+              return this._chromeJs(JSON.stringify(sel), `
+(function(s){var el=document.querySelector(s);if(!el)return 'NOT_FOUND: '+s;el.scrollIntoView({behavior:'instant',block:'center'});return 'Scrolled to: '+s;})(JSARG)
+`);
+            }
+            const scrollY = scrollDir === "up" ? -scrollAmt : scrollDir === "down" ? scrollAmt : 0;
+            const scrollX = scrollDir === "left" ? -scrollAmt : scrollDir === "right" ? scrollAmt : 0;
+            return this._chromeJs(JSON.stringify([scrollX, scrollY]), `
+(function(xy){window.scrollBy(xy[0],xy[1]);return 'Scrolled';} )(JSARG)
+`);
+          }
+          case "accessibility_click": {
+            const appName = String(input.app ?? "").trim();
+            const elemLabel = String(input.element ?? text ?? "").trim();
+            if (!appName || !elemLabel) return null;
+            const osName = platform2();
+            if (osName !== "darwin") return header + `print("accessibility_click is macOS only")`;
+            const safeApp = appName.replace(/'/g, "\\'");
+            const safeElem = elemLabel.replace(/'/g, "\\'");
+            return header + `
+import subprocess, time
+
+# Bring app to foreground
+subprocess.run(['osascript', '-e', 'tell application "${safeApp}" to activate'], capture_output=True)
+time.sleep(0.5)
+
+# Try clicking by name, then by description, then by value
+attempts = [
+    f'''tell application "System Events" to tell process "${safeApp}" to click (first UI element of front window whose name contains "${safeElem}")''',
+    f'''tell application "System Events" to tell process "${safeApp}" to click (first button whose description contains "${safeElem}")''',
+    f'''tell application "System Events" to tell process "${safeApp}" to click (first UI element whose value contains "${safeElem}")''',
+]
+
+success = False
+for script in attempts:
+    r = subprocess.run(['osascript', '-e', script], capture_output=True, text=True)
+    if r.returncode == 0:
+        print(f"Clicked '{${JSON.stringify(elemLabel)}}' in ${safeApp}")
+        success = True
+        break
+
+if not success:
+    # Last resort: try clicking the front window element matching description
+    list_script = f"""tell application "System Events"
+  tell process "${safeApp}"
+    return name of every UI element of front window
+  end tell
+end tell"""
+    lr = subprocess.run(['osascript', '-e', list_script], capture_output=True, text=True)
+    print(f"Could not find element '${safeElem}' in ${safeApp}")
+    print(f"Available elements: {lr.stdout.strip()[:300] or 'could not list'}")
+`;
+          }
+          case "cdp_screenshot": {
+            if (platform2() !== "darwin") return header + `print("cdp_screenshot is macOS only for now")`;
+            return header + `
+import urllib.request, json, base64, os, tempfile, subprocess
+
+def get_browser_state():
+    simple_scr = """tell application "Google Chrome"
+  tell front window
+    tell active tab
+      return URL & "|||" & title
+    end tell
+  end tell
+end tell"""
+    r = subprocess.run(['osascript', '-e', simple_scr], capture_output=True, text=True)
+    parts = r.stdout.strip().split('|||')
+    if len(parts) >= 2:
+        print(f"[No CDP screenshot] Tab: {parts[1]}")
+        print(f"URL: {parts[0]}")
+    else:
+        print("[No CDP screenshot \u2014 Chrome not running or no active tab]")
+    print("To enable screenshots without Screen Recording, start Chrome with:")
+    print("  /Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome --remote-debugging-port=9222")
+
+try:
+    tabs_raw = urllib.request.urlopen('http://localhost:9222/json', timeout=2).read()
+    tabs = json.loads(tabs_raw)
+    if not tabs:
+        raise Exception("No tabs available")
+    ws_url = tabs[0].get('webSocketDebuggerUrl', '')
+    if not ws_url:
+        raise Exception("No WebSocket URL")
+
+    # Auto-install websockets if needed
+    try:
+        import websockets
+    except ImportError:
+        subprocess.run(['pip3', 'install', 'websockets', '-q'], capture_output=True, timeout=60)
+        import websockets
+
+    import asyncio
+
+    async def capture():
+        async with websockets.connect(ws_url) as ws:
+            await ws.send(json.dumps({'id':1,'method':'Page.captureScreenshot','params':{'format':'jpeg','quality':75}}))
+            resp = json.loads(await ws.recv())
+            return resp.get('result', {}).get('data')
+
+    img_b64 = asyncio.run(capture())
+    if not img_b64:
+        raise Exception("No screenshot data returned")
+
+    out_path = os.path.join(tempfile.gettempdir(), '0agent_cdp_shot.jpg')
+    with open(out_path, 'wb') as f:
+        f.write(base64.b64decode(img_b64))
+
+    print(f"Screenshot: {out_path}")
+    print(f"Tab: {tabs[0].get('title','?')} \u2014 {tabs[0].get('url','?')[:80]}")
+
+    try:
+        import pytesseract
+        from PIL import Image
+        img = Image.open(out_path)
+        text = pytesseract.image_to_string(img, config='--psm 11')
+        lines = [l.strip() for l in text.splitlines() if l.strip()]
+        if lines:
+            print("On-screen text (OCR):\\n" + "\\n".join(lines[:50]))
+    except Exception:
+        print("(OCR not available \u2014 install pytesseract for text extraction)")
+
+except Exception as e:
+    get_browser_state()
+`;
+          }
+          case "exec_js": {
+            const js = String(input.js ?? "").trim();
+            if (!js) return null;
+            const osName = platform2();
+            if (osName !== "darwin") {
+              return header + `print("exec_js requires macOS + Google Chrome")`;
+            }
+            const jsJson = JSON.stringify(js);
+            return header + `
+import subprocess, json, os, tempfile
+
+js = json.loads(${jsJson})
+tmpjs = os.path.join(tempfile.gettempdir(), f"0agent_execjs_{os.getpid()}.js")
+with open(tmpjs, 'w') as f:
+    f.write(js)
+
+as_script = f'''tell application "Google Chrome"
+  tell front window
+    tell active tab
+      set jsCode to do shell script "cat '{tmpjs}'"
+      return execute javascript jsCode
+    end tell
+  end tell
+end tell'''
+
+r = subprocess.run(['osascript', '-e', as_script], capture_output=True, text=True)
+try: os.remove(tmpjs)
+except: pass
+
+if r.returncode == 0:
+    print(r.stdout.strip() if r.stdout.strip() else "(no return value)")
+else:
+    print(f"JS error: {r.stderr.strip()[:300]}")
+`;
+          }
+          case "browser_state": {
+            const osName = platform2();
+            if (osName !== "darwin") {
+              return header + `print("browser_state requires macOS + Google Chrome")`;
+            }
+            return header + `
+import subprocess
+
+as_script = '''tell application "Google Chrome"
+  tell front window
+    tell active tab
+      return URL & "|||" & title
+    end tell
+  end tell
+end tell'''
+
+r = subprocess.run(['osascript', '-e', as_script], capture_output=True, text=True)
+out = r.stdout.strip()
+if '|||' in out:
+    parts = out.split('|||', 1)
+    print(f"URL: {parts[0]}")
+    print(f"Title: {parts[1]}")
+else:
+    print(out or r.stderr.strip() or "Chrome not running or no active tab")
+`;
+          }
+          default:
+            return null;
+        }
+      }
+      /**
+       * Generate a Python script that runs JS in the current Chrome tab via AppleScript.
+       * jsArgJson is passed as variable JSARG inside the JS template.
+       * No Screen Recording needed — uses Chrome's built-in execute javascript.
+       */
+      _chromeJs(jsArgJson, jsTemplate) {
+        const finalJs = `var JSARG = ${jsArgJson};
+${jsTemplate.trim()}`;
+        const jsJson = JSON.stringify(finalJs);
+        return `
+import subprocess, json, os, tempfile
+
+js = json.loads(${jsJson})
+tmpjs = os.path.join(tempfile.gettempdir(), f"0agent_cjs_{os.getpid()}.js")
+with open(tmpjs, 'w') as f:
+    f.write(js)
+as_script = f"""tell application "Google Chrome"
+  tell front window
+    tell active tab
+      set jsCode to do shell script "cat '{tmpjs}'"
+      return execute javascript jsCode
+    end tell
+  end tell
+end tell"""
+r = subprocess.run(['osascript', '-e', as_script], capture_output=True, text=True)
+try: os.remove(tmpjs)
+except: pass
+result = r.stdout.strip()
+if r.returncode != 0:
+    print(f"JS error: {r.stderr.strip()[:300]}")
+elif result.startswith('NOT_FOUND:'):
+    print(f"Not found: {result[10:]} \u2014 call get_elements to see available elements")
+elif result.startswith('CLICKED:') or result.startswith('TYPED'):
+    print(f"OK {result}")
+else:
+    print(result if result else "(no return value)")
+`;
+      }
+    };
+  }
+});
+
+// packages/daemon/src/capabilities/OpenInterpreterCapability.ts
+import { spawn as spawn4 } from "node:child_process";
+import { writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
 var OI_SCRIPT, OpenInterpreterCapability;
 var init_OpenInterpreterCapability = __esm({
   "packages/daemon/src/capabilities/OpenInterpreterCapability.ts"() {
@@ -3104,11 +4027,11 @@ print(output if output else "Task completed successfully")
         const fullTask = context ? `Context: ${context}
 
 Task: ${task}` : task;
-        const tmpFile = resolve3(tmpdir(), `0agent_oi_${Date.now()}.py`);
-        writeFileSync2(tmpFile, OI_SCRIPT, "utf8");
+        const tmpFile = resolve4(tmpdir2(), `0agent_oi_${Date.now()}.py`);
+        writeFileSync3(tmpFile, OI_SCRIPT, "utf8");
         let result = await this._runScript(tmpFile, fullTask, signal);
         try {
-          unlinkSync(tmpFile);
+          unlinkSync2(tmpFile);
         } catch {
         }
         if (signal?.aborted) {
@@ -3124,10 +4047,10 @@ Run manually: pip3 install open-interpreter`,
               duration_ms: Date.now() - start
             };
           }
-          writeFileSync2(tmpFile, OI_SCRIPT, "utf8");
+          writeFileSync3(tmpFile, OI_SCRIPT, "utf8");
           result = await this._runScript(tmpFile, fullTask, signal);
           try {
-            unlinkSync(tmpFile);
+            unlinkSync2(tmpFile);
           } catch {
           }
           if (signal?.aborted) {
@@ -3147,8 +4070,8 @@ Run manually: pip3 install open-interpreter`,
       }
       /** Async pip install — never blocks the event loop (unlike spawnSync). */
       _pipInstall(pkg, signal) {
-        return new Promise((resolve16) => {
-          const proc = spawn3("pip3", ["install", pkg, "-q"], {
+        return new Promise((resolve17) => {
+          const proc = spawn4("pip3", ["install", pkg, "-q"], {
             env: process.env,
             stdio: "ignore"
           });
@@ -3158,7 +4081,7 @@ Run manually: pip3 install open-interpreter`,
             settled = true;
             signal?.removeEventListener("abort", onAbort);
             clearTimeout(timer);
-            resolve16(ok);
+            resolve17(ok);
           };
           const onAbort = () => {
             try {
@@ -3180,8 +4103,8 @@ Run manually: pip3 install open-interpreter`,
         });
       }
       _runScript(scriptPath, stdinData, signal) {
-        return new Promise((resolve16) => {
-          const proc = spawn3("python3", [scriptPath], {
+        return new Promise((resolve17) => {
+          const proc = spawn4("python3", [scriptPath], {
             env: process.env,
             stdio: ["pipe", "pipe", "pipe"]
           });
@@ -3193,7 +4116,7 @@ Run manually: pip3 install open-interpreter`,
             settled = true;
             signal?.removeEventListener("abort", onAbort);
             clearTimeout(timer);
-            resolve16({ stdout: out.join(""), stderr: err.join(""), code });
+            resolve17({ stdout: out.join(""), stderr: err.join(""), code });
           };
           const onAbort = () => {
             try {
@@ -3307,6 +4230,7 @@ var init_CapabilityRegistry = __esm({
     init_ShellCapability();
     init_FileCapability();
     init_MemoryCapability();
+    init_GUICapability();
     init_OpenInterpreterCapability();
     CapabilityRegistry = class {
       capabilities = /* @__PURE__ */ new Map();
@@ -3335,6 +4259,7 @@ var init_CapabilityRegistry = __esm({
         this.register(new ScraperCapability());
         this.register(new ShellCapability());
         this.register(new FileCapability());
+        this.register(new GUICapability());
         this.register(new OpenInterpreterCapability());
         if (graph) {
           this.register(new MemoryCapability(graph, onMemoryWrite));
@@ -3414,9 +4339,9 @@ var init_capabilities = __esm({
 });
 
 // packages/daemon/src/AgentExecutor.ts
-import { spawn as spawn4 } from "node:child_process";
-import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "node:fs";
-import { resolve as resolve4, dirname as dirname2, relative } from "node:path";
+import { spawn as spawn5 } from "node:child_process";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "node:fs";
+import { resolve as resolve5, dirname as dirname2, relative } from "node:path";
 import { homedir as homedir2 } from "node:os";
 var SELF_MOD_PATTERN, AgentExecutor;
 var init_AgentExecutor = __esm({
@@ -3611,9 +4536,9 @@ var init_AgentExecutor = __esm({
         }
       }
       shellExec(command, timeoutMs) {
-        return new Promise((resolve16) => {
+        return new Promise((resolve17) => {
           const chunks = [];
-          const proc = spawn4("bash", ["-c", command], {
+          const proc = spawn5("bash", ["-c", command], {
             cwd: this.cwd,
             env: { ...process.env, TERM: "dumb" },
             timeout: timeoutMs
@@ -3622,10 +4547,10 @@ var init_AgentExecutor = __esm({
           proc.stderr.on("data", (d) => chunks.push(d.toString()));
           proc.on("close", (code) => {
             const output = chunks.join("").trim();
-            resolve16(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
+            resolve17(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
           });
           proc.on("error", (err) => {
-            resolve16(`Error: ${err.message}`);
+            resolve17(`Error: ${err.message}`);
           });
         });
       }
@@ -3633,7 +4558,7 @@ var init_AgentExecutor = __esm({
         const safe = this.safePath(filePath);
         if (!safe) return "Error: path outside working directory";
         mkdirSync2(dirname2(safe), { recursive: true });
-        writeFileSync3(safe, content, "utf8");
+        writeFileSync4(safe, content, "utf8");
         const rel = relative(this.cwd, safe);
         return `Written: ${rel} (${content.length} bytes)`;
       }
@@ -3742,7 +4667,7 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
       }
       // ─── Helpers ───────────────────────────────────────────────────────────────
       safePath(p) {
-        const resolved = resolve4(this.cwd, p);
+        const resolved = resolve5(this.cwd, p);
         return resolved.startsWith(this.cwd) ? resolved : null;
       }
       buildSystemPrompt(extra, task) {
@@ -3783,20 +4708,21 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
         if (hasGUI) {
           lines.push(
             ``,
-            `GUI/Browser rules:`,
-            `1. open_url returns actual URL + title + "Video: PLAYING:1.4s \u2713" or "Video: PAUSED".`,
-            `   Read it. If video is PAUSED or title shows wrong page \u2014 take corrective action.`,
-            `2. exec_js: run JS in the current Chrome tab \u2014 NO Screen Recording needed.`,
-            `   MEDIA CONTROL \u2192 always use exec_js, never hotkey (hotkeys go to Terminal not Chrome):`,
-            `   pause:  {action:"exec_js",js:"document.querySelector('video').pause()"}`,
-            `   play:   {action:"exec_js",js:"document.querySelector('video').play()"}`,
-            `   check:  {action:"exec_js",js:"document.querySelector('video').paused+' t='+document.querySelector('video').currentTime"}`,
-            `   click:  {action:"exec_js",js:"document.querySelector('.some-selector').click()"}`,
-            `3. hotkey with app param: {action:"hotkey",keys:"k",app:"Google Chrome"} focuses Chrome first,`,
-            `   then sends the key via AppleScript (reliable). Without app param, key goes to Terminal.`,
-            `4. browser_state: quickly verify current tab URL + title after any navigation.`,
-            `5. NEVER claim success based on action alone. exec_js to verify: video.paused, page title, etc.`,
-            `6. computer_use: for multi-step desktop tasks \u2014 {task:"full goal description"}. No confirmation.`
+            `Browser/GUI actions \u2014 ALL work without Screen Recording permission:`,
+            `\u2022 click_text {text:"Submit"} \u2014 click any button/link/tab by its visible text. Use get_elements first if unsure.`,
+            `\u2022 type_in {selector:"search", text:"Drake"} \u2014 fill form field by placeholder or aria-label. Handles React events.`,
+            `\u2022 get_elements \u2014 list every button/link/input/heading on the page. ALWAYS call this first when navigating.`,
+            `\u2022 read_element {selector:"h1"} \u2014 read text of any element. selector="" reads full page.`,
+            `\u2022 get_media_state \u2014 returns {state:PLAYING/PAUSED, time, duration, volume}. Call after play/pause to verify.`,
+            `\u2022 scroll_to {selector:".result"} or {direction:"down", amount:400} \u2014 scroll page.`,
+            `\u2022 exec_js {js:"..."} \u2014 run arbitrary JS. Use for anything not covered above.`,
+            `\u2022 browser_state \u2014 get current URL + title. Call after any navigation.`,
+            `\u2022 cdp_screenshot \u2014 screenshot via Chrome DevTools Protocol (if Chrome has --remote-debugging-port=9222).`,
+            `\u2022 accessibility_click {app:"WhatsApp", element:"Send"} \u2014 click native macOS app button (no Screen Recording).`,
+            `\u2022 open_url {url:"..."} \u2014 navigate. Returns actual URL + title + video state. Read it.`,
+            `\u2022 hotkey {keys:"k", app:"Google Chrome"} \u2014 send key to specific app. Without app param: goes to Terminal.`,
+            `WORKFLOW: navigate \u2192 get_elements \u2192 click_text/type_in \u2192 get_media_state/browser_state to verify.`,
+            `NEVER assume success. Always verify with get_media_state, browser_state, or read_element.`
           );
         }
         if (isSelfMod && this.agentRoot) {
@@ -3809,10 +4735,10 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
           );
         }
         const agentsFiles = [
-          resolve4(this.cwd, "AGENTS.md"),
-          resolve4(this.cwd, ".0agent", "AGENTS.md"),
-          resolve4(this.cwd, "CLAUDE.md"),
-          resolve4(homedir2(), ".0agent", "AGENTS.md")
+          resolve5(this.cwd, "AGENTS.md"),
+          resolve5(this.cwd, ".0agent", "AGENTS.md"),
+          resolve5(this.cwd, "CLAUDE.md"),
+          resolve5(homedir2(), ".0agent", "AGENTS.md")
         ];
         for (const f of agentsFiles) {
           try {
@@ -3923,7 +4849,7 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
 
 // packages/daemon/src/ExecutionVerifier.ts
 import { existsSync as existsSync5 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 var ExecutionVerifier;
 var init_ExecutionVerifier = __esm({
   "packages/daemon/src/ExecutionVerifier.ts"() {
@@ -3960,7 +4886,7 @@ var init_ExecutionVerifier = __esm({
           };
         }
         if (files.length > 0) {
-          const lastFile = resolve5(this.cwd, files[files.length - 1]);
+          const lastFile = resolve6(this.cwd, files[files.length - 1]);
           const exists = existsSync5(lastFile);
           return {
             success: exists,
@@ -4000,10 +4926,10 @@ var init_ExecutionVerifier = __esm({
 });
 
 // packages/daemon/src/RuntimeSelfHeal.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "node:fs";
-import { resolve as resolve6, dirname as dirname3 } from "node:path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve7, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { execSync as execSync4, spawn as spawn5 } from "node:child_process";
+import { execSync as execSync4, spawn as spawn6 } from "node:child_process";
 function isRuntimeBug(error) {
   if (TASK_FAILURE_PATTERNS.some((p) => p.test(error))) return false;
   return RUNTIME_BUG_PATTERNS.some((p) => p.test(error));
@@ -4073,8 +4999,8 @@ var init_RuntimeSelfHeal = __esm({
         this.llm = llm;
         this.eventBus = eventBus;
         let dir = dirname3(fileURLToPath(import.meta.url));
-        while (dir !== "/" && !existsSync6(resolve6(dir, "package.json"))) {
-          dir = resolve6(dir, "..");
+        while (dir !== "/" && !existsSync6(resolve7(dir, "package.json"))) {
+          dir = resolve7(dir, "..");
         }
         this.projectRoot = dir;
       }
@@ -4120,7 +5046,7 @@ var init_RuntimeSelfHeal = __esm({
         try {
           const original = readFileSync5(tsPath, "utf8");
           const backup = tsPath + ".bak";
-          writeFileSync4(backup, original, "utf8");
+          writeFileSync5(backup, original, "utf8");
           if (!original.includes(proposal.original_code.trim())) {
             return {
               applied: false,
@@ -4129,8 +5055,8 @@ var init_RuntimeSelfHeal = __esm({
             };
           }
           const patched = original.replace(proposal.original_code, proposal.proposed_code);
-          writeFileSync4(tsPath, patched, "utf8");
-          const bundleScript = resolve6(this.projectRoot, "scripts", "bundle.mjs");
+          writeFileSync5(tsPath, patched, "utf8");
+          const bundleScript = resolve7(this.projectRoot, "scripts", "bundle.mjs");
           if (existsSync6(bundleScript)) {
             try {
               execSync4(`node "${bundleScript}"`, {
@@ -4139,7 +5065,7 @@ var init_RuntimeSelfHeal = __esm({
                 stdio: "ignore"
               });
             } catch {
-              writeFileSync4(tsPath, original, "utf8");
+              writeFileSync5(tsPath, original, "utf8");
               return {
                 applied: false,
                 restarted: false,
@@ -4164,11 +5090,11 @@ var init_RuntimeSelfHeal = __esm({
       // ─── Private helpers ───────────────────────────────────────────────────────
       findSourceFile(location) {
         const candidates = [
-          resolve6(this.projectRoot, location.relPath),
+          resolve7(this.projectRoot, location.relPath),
           // If relPath starts with dist/, look in src/
-          resolve6(this.projectRoot, location.relPath.replace(/^dist\//, "src/").replace(/\.js$/, ".ts")),
-          resolve6(this.projectRoot, "packages", "daemon", "src", location.relPath.replace(/.*src\//, "")),
-          resolve6(this.projectRoot, "packages", "core", "src", location.relPath.replace(/.*src\//, ""))
+          resolve7(this.projectRoot, location.relPath.replace(/^dist\//, "src/").replace(/\.js$/, ".ts")),
+          resolve7(this.projectRoot, "packages", "daemon", "src", location.relPath.replace(/.*src\//, "")),
+          resolve7(this.projectRoot, "packages", "core", "src", location.relPath.replace(/.*src\//, ""))
         ];
         for (const p of candidates) {
           if (existsSync6(p)) return p;
@@ -4236,9 +5162,9 @@ Rules:
         }
       }
       restartDaemon() {
-        const bundlePath = resolve6(this.projectRoot, "dist", "daemon.mjs");
+        const bundlePath = resolve7(this.projectRoot, "dist", "daemon.mjs");
         if (existsSync6(bundlePath)) {
-          const child = spawn5(process.execPath, [bundlePath], {
+          const child = spawn6(process.execPath, [bundlePath], {
             detached: true,
             stdio: "ignore",
             env: process.env
@@ -4343,7 +5269,7 @@ __export(ProactiveSurface_exports, {
 });
 import { execSync as execSync7 } from "node:child_process";
 import { existsSync as existsSync16, readFileSync as readFileSync14, statSync, readdirSync as readdirSync5 } from "node:fs";
-import { resolve as resolve13, join as join6 } from "node:path";
+import { resolve as resolve14, join as join6 } from "node:path";
 function readdirSafe(dir) {
   try {
     return readdirSync5(dir);
@@ -4392,7 +5318,7 @@ var init_ProactiveSurface = __esm({
         return [...this.insights];
       }
       async poll() {
-        if (!existsSync16(resolve13(this.cwd, ".git"))) return;
+        if (!existsSync16(resolve14(this.cwd, ".git"))) return;
         const newInsights = [];
         const gitInsight = this.checkGitActivity();
         if (gitInsight) newInsights.push(gitInsight);
@@ -4497,8 +5423,8 @@ var init_ProactiveSurface = __esm({
 
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_src();
-import { writeFileSync as writeFileSync11, unlinkSync as unlinkSync3, existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync15 } from "node:fs";
-import { resolve as resolve14 } from "node:path";
+import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync15 } from "node:fs";
+import { resolve as resolve15 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 
 // packages/daemon/src/config/DaemonConfig.ts
@@ -5000,19 +5926,19 @@ var ProjectScanner = class {
   async getRunningPorts() {
     const open = [];
     await Promise.all(PORTS_TO_CHECK.map(
-      (port) => new Promise((resolve16) => {
+      (port) => new Promise((resolve17) => {
         const s = createServer();
         s.listen(port, "127.0.0.1", () => {
           s.close();
-          resolve16();
+          resolve17();
         });
         s.on("error", () => {
           open.push(port);
-          resolve16();
+          resolve17();
         });
         setTimeout(() => {
           s.close();
-          resolve16();
+          resolve17();
         }, 200);
       })
     ));
@@ -5089,7 +6015,7 @@ var ConversationStore = class {
 
 // packages/daemon/src/SessionManager.ts
 import { readFileSync as readFileSync6, existsSync as existsSync7 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve8 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 import YAML2 from "yaml";
 var SessionManager = class {
@@ -5466,7 +6392,7 @@ Current task:`;
           model: agentResult.model
         });
       } else {
-        const cfgPath = resolve7(homedir3(), ".0agent", "config.yaml");
+        const cfgPath = resolve8(homedir3(), ".0agent", "config.yaml");
         const output = `No LLM API key found. Add one to ${cfgPath} or run: 0agent init`;
         this.addStep(sessionId, "\u26A0 No LLM API key configured \u2014 run: 0agent init");
         this.completeSession(sessionId, { output });
@@ -5509,7 +6435,7 @@ Current task:`;
    */
   getFreshLLM() {
     try {
-      const configPath = resolve7(homedir3(), ".0agent", "config.yaml");
+      const configPath = resolve8(homedir3(), ".0agent", "config.yaml");
       if (!existsSync7(configPath)) return this.llm;
       const raw = readFileSync6(configPath, "utf8");
       const cfg = YAML2.parse(raw);
@@ -5537,7 +6463,7 @@ Current task:`;
     if (!this.graph) return;
     let extractLLM;
     try {
-      const cfgPath = resolve7(homedir3(), ".0agent", "config.yaml");
+      const cfgPath = resolve8(homedir3(), ".0agent", "config.yaml");
       if (existsSync7(cfgPath)) {
         const raw = readFileSync6(cfgPath, "utf8");
         const cfg = YAML2.parse(raw);
@@ -5902,7 +6828,7 @@ var BackgroundWorkers = class {
 };
 
 // packages/daemon/src/SkillRegistry.ts
-import { readFileSync as readFileSync7, readdirSync as readdirSync3, existsSync as existsSync8, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3 } from "node:fs";
+import { readFileSync as readFileSync7, readdirSync as readdirSync3, existsSync as existsSync8, writeFileSync as writeFileSync6, unlinkSync as unlinkSync3, mkdirSync as mkdirSync3 } from "node:fs";
 import { join as join2 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import YAML3 from "yaml";
@@ -5966,7 +6892,7 @@ var SkillRegistry = class {
     }
     mkdirSync3(this.customDir, { recursive: true });
     const filePath = join2(this.customDir, `${name}.yaml`);
-    writeFileSync5(filePath, yamlContent, "utf8");
+    writeFileSync6(filePath, yamlContent, "utf8");
     const skill = YAML3.parse(yamlContent);
     this.skills.set(name, skill);
     return skill;
@@ -5980,7 +6906,7 @@ var SkillRegistry = class {
     }
     const filePath = join2(this.customDir, `${name}.yaml`);
     if (existsSync8(filePath)) {
-      unlinkSync2(filePath);
+      unlinkSync3(filePath);
     }
     this.skills.delete(name);
   }
@@ -5993,7 +6919,7 @@ var SkillRegistry = class {
 import { Hono as Hono14 } from "hono";
 import { serve } from "@hono/node-server";
 import { readFileSync as readFileSync9 } from "node:fs";
-import { resolve as resolve9, dirname as dirname4 } from "node:path";
+import { resolve as resolve10, dirname as dirname4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/daemon/src/routes/health.ts
@@ -6286,7 +7212,7 @@ function memoryRoutes(deps) {
 init_LLMExecutor();
 import { Hono as Hono10 } from "hono";
 import { readFileSync as readFileSync8, existsSync as existsSync9 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import YAML4 from "yaml";
 function llmRoutes() {
@@ -6294,7 +7220,7 @@ function llmRoutes() {
   app.post("/ping", async (c) => {
     const start = Date.now();
     try {
-      const configPath = resolve8(homedir5(), ".0agent", "config.yaml");
+      const configPath = resolve9(homedir5(), ".0agent", "config.yaml");
       if (!existsSync9(configPath)) {
         return c.json({ ok: false, error: "Config not found. Run: 0agent init" });
       }
@@ -6813,11 +7739,11 @@ function runtimeRoutes(deps) {
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
-    resolve9(dirname4(fileURLToPath2(import.meta.url)), "graph.html"),
+    resolve10(dirname4(fileURLToPath2(import.meta.url)), "graph.html"),
     // dev (src/)
-    resolve9(dirname4(fileURLToPath2(import.meta.url)), "..", "graph.html"),
+    resolve10(dirname4(fileURLToPath2(import.meta.url)), "..", "graph.html"),
     // bundled (dist/../)
-    resolve9(dirname4(fileURLToPath2(import.meta.url)), "..", "dist", "graph.html")
+    resolve10(dirname4(fileURLToPath2(import.meta.url)), "..", "dist", "graph.html")
   ];
   for (const p of candidates) {
     try {
@@ -6867,7 +7793,7 @@ var HTTPServer = class {
     this.app.get("/graph", serveGraph);
   }
   start() {
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -6875,20 +7801,20 @@ var HTTPServer = class {
           hostname: this.deps.host
         },
         () => {
-          resolve16();
+          resolve17();
         }
       );
     });
   }
   stop() {
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       if (!this.server) {
-        resolve16();
+        resolve17();
         return;
       }
       this.server.close((err) => {
         if (err) reject(err);
-        else resolve16();
+        else resolve17();
       });
     });
   }
@@ -6902,11 +7828,11 @@ init_LLMExecutor();
 
 // packages/daemon/src/IdentityManager.ts
 init_src();
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
-import { resolve as resolve10, dirname as dirname5 } from "node:path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
+import { resolve as resolve11, dirname as dirname5 } from "node:path";
 import { homedir as homedir6, hostname } from "node:os";
 import YAML5 from "yaml";
-var IDENTITY_PATH = resolve10(homedir6(), ".0agent", "identity.yaml");
+var IDENTITY_PATH = resolve11(homedir6(), ".0agent", "identity.yaml");
 var DEFAULT_IDENTITY = {
   name: "User",
   device_id: `unknown-device`,
@@ -6978,16 +7904,16 @@ var IdentityManager = class {
     if (!existsSync10(dir)) {
       mkdirSync4(dir, { recursive: true });
     }
-    writeFileSync6(IDENTITY_PATH, YAML5.stringify(this.identity), "utf8");
+    writeFileSync7(IDENTITY_PATH, YAML5.stringify(this.identity), "utf8");
   }
 };
 
 // packages/daemon/src/TeamManager.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "node:fs";
-import { resolve as resolve11 } from "node:path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "node:fs";
+import { resolve as resolve12 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 import YAML6 from "yaml";
-var TEAMS_PATH = resolve11(homedir7(), ".0agent", "teams.yaml");
+var TEAMS_PATH = resolve12(homedir7(), ".0agent", "teams.yaml");
 var TeamManager = class {
   config;
   constructor() {
@@ -7047,8 +7973,8 @@ var TeamManager = class {
     }
   }
   save() {
-    mkdirSync5(resolve11(homedir7(), ".0agent"), { recursive: true });
-    writeFileSync7(TEAMS_PATH, YAML6.stringify(this.config), "utf8");
+    mkdirSync5(resolve12(homedir7(), ".0agent"), { recursive: true });
+    writeFileSync8(TEAMS_PATH, YAML6.stringify(this.config), "utf8");
   }
 };
 
@@ -7131,8 +8057,8 @@ var TeamSync = class {
 };
 
 // packages/daemon/src/GitHubMemorySync.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, readdirSync as readdirSync4 } from "node:fs";
-import { resolve as resolve12 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync12, readdirSync as readdirSync4 } from "node:fs";
+import { resolve as resolve13 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 var GITHUB_API = "https://api.github.com";
 async function ghFetch(path, token, opts) {
@@ -7252,10 +8178,10 @@ var GitHubMemorySync = class {
           )
         );
       }
-      const customSkillsDir = resolve12(homedir8(), ".0agent", "skills", "custom");
+      const customSkillsDir = resolve13(homedir8(), ".0agent", "skills", "custom");
       if (existsSync12(customSkillsDir)) {
         for (const file of readdirSync4(customSkillsDir).filter((f) => f.endsWith(".yaml"))) {
-          const content = readFileSync12(resolve12(customSkillsDir, file), "utf8");
+          const content = readFileSync12(resolve13(customSkillsDir, file), "utf8");
           pushes.push(putFile(token, owner, repo, `skills/custom/${file}`, content, commitMsg));
         }
       }
@@ -7441,7 +8367,7 @@ var GitHubMemorySync = class {
   }
   async pullCustomSkills() {
     const { token, owner, repo } = this.config;
-    const dir = resolve12(homedir8(), ".0agent", "skills", "custom");
+    const dir = resolve13(homedir8(), ".0agent", "skills", "custom");
     try {
       const res = await ghFetch(`/repos/${owner}/${repo}/contents/skills/custom`, token);
       if (!res.ok) return;
@@ -7451,7 +8377,7 @@ var GitHubMemorySync = class {
         if (content) {
           const { mkdirSync: mkdirSync10 } = await import("node:fs");
           mkdirSync10(dir, { recursive: true });
-          writeFileSync8(resolve12(dir, file.name), content, "utf8");
+          writeFileSync9(resolve13(dir, file.name), content, "utf8");
         }
       }
     } catch {
@@ -7528,7 +8454,7 @@ git checkout <commit> graph/         # restore graph files
 };
 
 // packages/daemon/src/CodespaceManager.ts
-import { execSync as execSync5, spawn as spawn6 } from "node:child_process";
+import { execSync as execSync5, spawn as spawn7 } from "node:child_process";
 var BROWSER_PORT_REMOTE = 3e3;
 var BROWSER_PORT_LOCAL = 3001;
 var DISPLAY_NAME = "0agent-browser";
@@ -7623,7 +8549,7 @@ var CodespaceManager = class {
   async openTunnel(name) {
     this.closeTunnel();
     console.log(`[Codespace] Opening tunnel port ${BROWSER_PORT_REMOTE} \u2192 localhost:${BROWSER_PORT_LOCAL}...`);
-    this.forwardProcess = spawn6(
+    this.forwardProcess = spawn7(
       "gh",
       ["codespace", "ports", "forward", `${BROWSER_PORT_REMOTE}:${BROWSER_PORT_LOCAL}`, "--codespace", name],
       { stdio: ["ignore", "ignore", "ignore"] }
@@ -8073,7 +8999,7 @@ var SurfaceRouter = class {
 
 // packages/daemon/src/surfaces/TelegramAdapter.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync6 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
+import { tmpdir as tmpdir3 } from "node:os";
 import { join as join3 } from "node:path";
 var TelegramAdapter = class {
   constructor(config) {
@@ -8278,15 +9204,15 @@ Sessions: ${h.active_sessions} active`
     try {
       const fileUrl = await this._getFileUrl(fileId);
       if (!fileUrl) return null;
-      const tmpDir = join3(tmpdir2(), "0agent-voice");
+      const tmpDir = join3(tmpdir3(), "0agent-voice");
       if (!existsSync13(tmpDir)) mkdirSync6(tmpDir, { recursive: true });
       const tmpPath = join3(tmpDir, `${fileId}.ogg`);
       const wavPath = join3(tmpDir, `${fileId}.wav`);
       const res = await fetch(fileUrl);
       if (!res.ok) return null;
       const buf = await res.arrayBuffer();
-      const { writeFileSync: writeFileSync12 } = await import("node:fs");
-      writeFileSync12(tmpPath, Buffer.from(buf));
+      const { writeFileSync: writeFileSync13 } = await import("node:fs");
+      writeFileSync13(tmpPath, Buffer.from(buf));
       const { execSync: execSync8 } = await import("node:child_process");
       try {
         execSync8(`ffmpeg -y -i "${tmpPath}" -ar 16000 -ac 1 "${wavPath}" 2>/dev/null`, { timeout: 3e4 });
@@ -8742,9 +9668,9 @@ var WhatsAppAdapter = class {
 import * as readline from "node:readline";
 
 // packages/daemon/src/surfaces/WhisperSTT.ts
-import { execSync as execSync6, spawnSync as spawnSync4 } from "node:child_process";
+import { execSync as execSync6, spawnSync as spawnSync5 } from "node:child_process";
 import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync13 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
+import { tmpdir as tmpdir4 } from "node:os";
 import { join as join4, basename } from "node:path";
 var WhisperSTT = class _WhisperSTT {
   model;
@@ -8765,7 +9691,7 @@ var WhisperSTT = class _WhisperSTT {
       console.warn(`[WhisperSTT] Audio file not found: ${audioPath}`);
       return null;
     }
-    const outDir = join4(tmpdir3(), "0agent-whisper");
+    const outDir = join4(tmpdir4(), "0agent-whisper");
     if (!existsSync14(outDir)) mkdirSync7(outDir, { recursive: true });
     try {
       const langFlag = this.language ? `--language ${this.language}` : "";
@@ -8789,7 +9715,7 @@ var WhisperSTT = class _WhisperSTT {
   static detectBinary() {
     for (const bin of ["whisper", "faster-whisper", "whisper.cpp"]) {
       try {
-        const result = spawnSync4(bin, ["--help"], { timeout: 3e3, stdio: "pipe" });
+        const result = spawnSync5(bin, ["--help"], { timeout: 3e3, stdio: "pipe" });
         if (result.status === 0 || result.status === 1) return bin;
       } catch {
       }
@@ -8798,25 +9724,25 @@ var WhisperSTT = class _WhisperSTT {
   }
 };
 async function recordAudio(durationSeconds) {
-  const outDir = join4(tmpdir3(), "0agent-voice");
+  const outDir = join4(tmpdir4(), "0agent-voice");
   if (!existsSync14(outDir)) mkdirSync7(outDir, { recursive: true });
   const outPath = join4(outDir, `recording-${Date.now()}.wav`);
-  const soxResult = spawnSync4(
+  const soxResult = spawnSync5(
     "sox",
     ["-d", "-r", "16000", "-c", "1", "-b", "16", outPath, "trim", "0", String(durationSeconds)],
     { timeout: (durationSeconds + 5) * 1e3, stdio: "pipe" }
   );
   if (soxResult.status === 0 && existsSync14(outPath)) return outPath;
-  const platform2 = process.platform;
+  const platform3 = process.platform;
   let ffmpegDevice;
-  if (platform2 === "darwin") {
+  if (platform3 === "darwin") {
     ffmpegDevice = ["-f", "avfoundation", "-i", ":0"];
-  } else if (platform2 === "linux") {
+  } else if (platform3 === "linux") {
     ffmpegDevice = ["-f", "alsa", "-i", "default"];
   } else {
     return null;
   }
-  const ffmpegResult = spawnSync4(
+  const ffmpegResult = spawnSync5(
     "ffmpeg",
     ["-y", ...ffmpegDevice, "-ar", "16000", "-ac", "1", "-t", String(durationSeconds), outPath],
     { timeout: (durationSeconds + 5) * 1e3, stdio: "pipe" }
@@ -8825,7 +9751,7 @@ async function recordAudio(durationSeconds) {
 }
 
 // packages/daemon/src/surfaces/NativeTTS.ts
-import { spawnSync as spawnSync5, spawn as spawn7 } from "node:child_process";
+import { spawnSync as spawnSync6, spawn as spawn8 } from "node:child_process";
 var NativeTTS = class _NativeTTS {
   engine;
   voice;
@@ -8849,11 +9775,11 @@ var NativeTTS = class _NativeTTS {
     if (!this.resolvedEngine) return;
     const cleaned = this._clean(text);
     if (!cleaned) return;
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       const args = this._buildArgs(this.resolvedEngine, cleaned);
-      const proc = spawn7(this.resolvedEngine, args, { stdio: "ignore" });
-      proc.on("close", () => resolve16());
-      proc.on("error", () => resolve16());
+      const proc = spawn8(this.resolvedEngine, args, { stdio: "ignore" });
+      proc.on("close", () => resolve17());
+      proc.on("error", () => resolve17());
     });
   }
   /** Check if any TTS engine is available */
@@ -8867,8 +9793,8 @@ var NativeTTS = class _NativeTTS {
     return _NativeTTS._detectEngine();
   }
   static _detectEngine() {
-    const platform2 = process.platform;
-    if (platform2 === "darwin") {
+    const platform3 = process.platform;
+    if (platform3 === "darwin") {
       if (_NativeTTS._isAvailable("say")) return "say";
     }
     if (_NativeTTS._isAvailable("piper")) return "piper";
@@ -8878,7 +9804,7 @@ var NativeTTS = class _NativeTTS {
   }
   static _isAvailable(engine) {
     try {
-      const r = spawnSync5(engine, ["--help"], { timeout: 2e3, stdio: "pipe" });
+      const r = spawnSync6(engine, ["--help"], { timeout: 2e3, stdio: "pipe" });
       return r.status === 0 || r.status === 1;
     } catch {
       return false;
@@ -8911,7 +9837,7 @@ var NativeTTS = class _NativeTTS {
   }
   _speakWith(engine, text) {
     const args = this._buildArgs(engine, text);
-    const proc = spawn7(engine, args, { stdio: "ignore", detached: true });
+    const proc = spawn8(engine, args, { stdio: "ignore", detached: true });
     proc.unref();
   }
   /** Remove markdown/ANSI and control chars before speaking */
@@ -9036,10 +9962,10 @@ var VoiceAdapter = class {
 };
 
 // packages/daemon/src/surfaces/MeetingAdapter.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, writeFileSync as writeFileSync10 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { tmpdir as tmpdir5 } from "node:os";
 import { join as join5 } from "node:path";
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 var MeetingAdapter = class {
   name = "meeting";
   messageHandler = null;
@@ -9063,7 +9989,7 @@ var MeetingAdapter = class {
     this.silenceTimeoutSeconds = config.silence_timeout_seconds ?? 60;
     this.triggerPhrases = config.trigger_phrases ?? ["agent,", "hey agent", "ok agent"];
     this.contextWindowSeconds = config.context_window_seconds ?? 120;
-    this.tmpDir = join5(tmpdir4(), "0agent-meeting");
+    this.tmpDir = join5(tmpdir5(), "0agent-meeting");
     if (!existsSync15(this.tmpDir)) mkdirSync8(this.tmpDir, { recursive: true });
     this.stt = new WhisperSTT({ model: config.whisper_model ?? "base" });
   }
@@ -9170,26 +10096,26 @@ ${msg.text}
     }
   }
   async _captureSystemAudio(outPath, seconds) {
-    return new Promise((resolve16) => {
-      const platform2 = process.platform;
+    return new Promise((resolve17) => {
+      const platform3 = process.platform;
       let args;
-      if (platform2 === "darwin") {
+      if (platform3 === "darwin") {
         args = ["-y", "-f", "avfoundation", "-i", ":1", "-ar", "16000", "-ac", "1", "-t", String(seconds), outPath];
-      } else if (platform2 === "linux") {
+      } else if (platform3 === "linux") {
         args = ["-y", "-f", "pulse", "-i", "default.monitor", "-ar", "16000", "-ac", "1", "-t", String(seconds), outPath];
       } else {
-        resolve16(false);
+        resolve17(false);
         return;
       }
-      const proc = spawn8("ffmpeg", args, { stdio: "pipe" });
+      const proc = spawn9("ffmpeg", args, { stdio: "pipe" });
       this.ffmpegProcess = proc;
       proc.on("close", (code) => {
         this.ffmpegProcess = null;
-        resolve16(code === 0);
+        resolve17(code === 0);
       });
       proc.on("error", () => {
         this.ffmpegProcess = null;
-        resolve16(false);
+        resolve17(false);
       });
     });
   }
@@ -9248,13 +10174,13 @@ ${fullTranscript}`,
     const content = `Meeting Transcript
 ${"=".repeat(40)}
 ${this.getTranscript()}`;
-    writeFileSync10(outPath, content, "utf8");
+    writeFileSync11(outPath, content, "utf8");
     return outPath;
   }
   static isAvailable() {
     try {
-      const { spawnSync: spawnSync6 } = __require("node:child_process");
-      const r = spawnSync6("ffmpeg", ["-version"], { timeout: 2e3, stdio: "pipe" });
+      const { spawnSync: spawnSync7 } = __require("node:child_process");
+      const r = spawnSync7("ffmpeg", ["-version"], { timeout: 2e3, stdio: "pipe" });
       return r.status === 0;
     } catch {
       return false;
@@ -9287,11 +10213,11 @@ var ZeroAgentDaemon = class {
   startedAt = 0;
   pidFilePath;
   constructor() {
-    this.pidFilePath = resolve14(homedir9(), ".0agent", "daemon.pid");
+    this.pidFilePath = resolve15(homedir9(), ".0agent", "daemon.pid");
   }
   async start(opts) {
     this.config = await loadConfig(opts?.config_path);
-    const dotDir = resolve14(homedir9(), ".0agent");
+    const dotDir = resolve15(homedir9(), ".0agent");
     if (!existsSync17(dotDir)) {
       mkdirSync9(dotDir, { recursive: true });
     }
@@ -9366,10 +10292,10 @@ var ZeroAgentDaemon = class {
       console.log(`[0agent] Teams: ${teams.map((t) => t.team_name).join(", ")}`);
     }
     const _daemonFile = fileURLToPath3(import.meta.url);
-    const _agentRoot = resolve14(dirname7(_daemonFile), "..");
+    const _agentRoot = resolve15(dirname7(_daemonFile), "..");
     let agentRoot;
     try {
-      const _pkg = JSON.parse(readFileSync15(resolve14(_agentRoot, "package.json"), "utf8"));
+      const _pkg = JSON.parse(readFileSync15(resolve15(_agentRoot, "package.json"), "utf8"));
       if (_pkg.name === "0agent") agentRoot = _agentRoot;
     } catch {
     }
@@ -9521,7 +10447,7 @@ var ZeroAgentDaemon = class {
       }
     });
     await this.httpServer.start();
-    writeFileSync11(this.pidFilePath, String(process.pid), "utf8");
+    writeFileSync12(this.pidFilePath, String(process.pid), "utf8");
     console.log(
       `[0agent] Daemon started on ${this.config.server.host}:${this.config.server.port} (PID: ${process.pid})`
     );
@@ -9575,7 +10501,7 @@ var ZeroAgentDaemon = class {
     this.adapter = null;
     if (existsSync17(this.pidFilePath)) {
       try {
-        unlinkSync3(this.pidFilePath);
+        unlinkSync4(this.pidFilePath);
       } catch {
       }
     }
@@ -9603,10 +10529,10 @@ var ZeroAgentDaemon = class {
 };
 
 // packages/daemon/src/start.ts
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 import { homedir as homedir10 } from "node:os";
 import { existsSync as existsSync18 } from "node:fs";
-var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve15(homedir10(), ".0agent", "config.yaml");
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve16(homedir10(), ".0agent", "config.yaml");
 if (!existsSync18(CONFIG_PATH)) {
   console.error(`
   0agent is not initialised.