browsentic 0.6.0 → 0.7.0

package/dist/cli.js

@@ -11765,8 +11765,8 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
   return typeof message === "string" ? message : message?.message;
 }
-function finalizeIssue(iss, ctx, config2) {
-  const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+function finalizeIssue(iss, ctx, config4) {
+  const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config4.customError?.(iss)) ?? unwrapMessage(config4.localeError?.(iss)) ?? "Invalid input";
   const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
   rest.path ?? (rest.path = []);
   rest.message = message;
@@ -27992,6 +27992,7 @@ function pressEnterIn(el) {
 // ../lib/actions/page/find-captcha.ts
 var findCaptcha = defineAction({
   name: "page.findCaptcha",
+  chromiumOnly: true,
   description: "Look for a captcha on the page and report what it is, without touching it. Ordinary selectors cannot see one: vendors build the widget inside a closed shadow root holding a cross-origin iframe holding another shadow root, so page.getPageInfo shows nothing where the captcha visibly is. This reads through all of that with Chrome\u2019s debugger and reports the vendor (Cloudflare Turnstile, reCAPTCHA v2/v3, hCaptcha, GeeTest, Arkose, AWS WAF), the widget\u2019s on-screen bounds, whether it is already satisfied, and a viewport point for its checkbox when it has one. Read-only \u2014 it never clicks. Call it when a page stalls on \u201Cverifying you are human\u201D, refuses a form for no visible reason, or shows a checkbox no selector can find. Chrome only, and it briefly shows the \u201CBrowsentic is debugging this browser\u201D bar.",
   input: external_exports.object({}),
   execute() {
@@ -28356,11 +28357,14 @@ var LANDMARK_ROLES = /* @__PURE__ */ new Set([
 ]);
 var getPageInfo = defineAction({
   name: "page.getPageInfo",
-  description: 'Snapshot the current page: document metadata, viewport and scroll state, a semantic layout tree with a text diagram, the heading outline, and an inventory of interactive elements \u2014 each carrying its ARIA role, its live state (disabled, checked, expanded, filled, aria-current) and the landmark region it sits in. When the site registers WebMCP tools, the result also carries a siteTools list \u2014 prefer page.callSiteTool over clicking wherever a listed tool covers the step. Visible iframes come back under "frames"; nothing inside one is in this snapshot until page.switchFrame enters it, and "frame" then says which one is in focus.',
+  description: 'Snapshot the current page: document metadata, viewport and scroll state, a text diagram of the landmark regions with a selector for each, the heading outline, and an inventory of interactive elements \u2014 each carrying its ARIA role, its live state (disabled, checked, expanded, filled, aria-current) and the landmark region it sits in. When the site registers WebMCP tools, the result also carries a siteTools list \u2014 prefer page.callSiteTool over clicking wherever a listed tool covers the step. Visible iframes come back under "frames"; nothing inside one is in this snapshot until page.switchFrame enters it, and "frame" then says which one is in focus.',
   input: external_exports.object({
-    maxPerKind: external_exports.number().int().positive().default(30).describe("Cap on links, buttons, fields, and forms listed per kind")
+    maxPerKind: external_exports.number().int().positive().default(30).describe("Cap on links, buttons, fields, and forms listed per kind"),
+    geometry: external_exports.boolean().default(false).describe(
+      'Add each element\u2019s "bounds" in document pixels. Off by default: a selector or visible text is what the other tools target by, so ask only when you need coordinates \u2014 a point for page.trustedClick or page.dragElement.'
+    )
   }),
-  execute({ maxPerKind }) {
+  execute({ maxPerKind, geometry }) {
     const { regions, owners } = layoutTree();
     const found = collect();
     tally(found, owners);
@@ -28380,25 +28384,25 @@ var getPageInfo = defineAction({
         pageHeight: document.documentElement.scrollHeight
       },
       selection: getSelection()?.toString().slice(0, 500) || void 0,
-      layout: { regions, diagram: renderDiagram(regions) },
+      layout: { diagram: renderDiagram(regions) },
       outline: [...document.querySelectorAll("h1,h2,h3,h4,h5,h6")].filter(isExposed).slice(0, 60).map((heading) => ({
         level: Number(heading.tagName[1]),
         text: accessibleText(heading).slice(0, 120)
       })),
-      interactive: inventory(found, owners, maxPerKind),
-      frames: embeddedFrames()
+      interactive: inventory(found, owners, maxPerKind, geometry),
+      frames: embeddedFrames(geometry)
     };
   }
 });
 var MAX_FRAMES = 20;
-function embeddedFrames() {
+function embeddedFrames(geometry) {
   const frames = [...document.querySelectorAll("iframe,frame")].filter(isFrameElement).filter(isExposed).slice(0, MAX_FRAMES).map((frame) => ({
     selector: cssPath(frame),
     src: frame.src || void 0,
     name: frame.name || void 0,
     title: frame.title || void 0,
     sandbox: sandboxOf(frame),
-    bounds: documentBounds(frame)
+    bounds: geometry ? documentBounds(frame) : void 0
   }));
   return frames.length ? frames : void 0;
 }
@@ -28457,7 +28461,7 @@ function renderDiagram(regions) {
       const { bounds, contains: contains2 } = region;
       const counts = ["links", "buttons", "fields"].filter((kind) => contains2[kind] > 0).map((kind) => ` \xB7 ${contains2[kind]} ${kind}`).join("");
       lines.push(
-        `${indent}${last ? "\u2514" : "\u251C"} ${regionName(region)} \xB7 ${bounds.width}\xD7${bounds.height} @ (${bounds.x},${bounds.y})${counts}`
+        `${indent}${last ? "\u2514" : "\u251C"} ${regionName(region)} \xB7 ${bounds.width}\xD7${bounds.height} @ (${bounds.x},${bounds.y})${counts} \xB7 selector: ${region.selector}`
       );
       walk2(region.children, indent + (last ? "  " : "\u2502 "));
     });
@@ -28484,23 +28488,28 @@ function tally(found, owners) {
     }
   }
 }
-function inventory(found, owners, cap) {
+function inventory(found, owners, cap, geometry) {
   const regionFor = (el) => {
     const owner = ownerOf(el, owners);
     return owner && regionName(owner);
   };
+  const entry = (el, implied) => {
+    const { tag: tag2, role, bounds, ...rest } = describeElement(el);
+    const said = implied?.tag === tag2 && implied.role === role;
+    return { ...said ? {} : { tag: tag2, role }, ...rest, ...geometry ? { bounds } : {} };
+  };
   return {
     links: found.links.slice(0, cap).map((link) => ({
-      ...describeElement(link),
+      ...entry(link, { tag: "a", role: "link" }),
       href: link.href,
       region: regionFor(link)
     })),
     buttons: found.buttons.slice(0, cap).map((button) => ({
-      ...describeElement(button),
+      ...entry(button, { tag: "button", role: "button" }),
       region: regionFor(button)
     })),
     fields: found.fields.slice(0, cap).map((field) => ({
-      ...describeElement(field),
+      ...entry(field),
       kind: field instanceof HTMLInputElement ? field.type : field.tagName.toLowerCase(),
       region: regionFor(field)
     })),
@@ -28588,7 +28597,8 @@ var hoverElement = defineAction({
 var MAX_CODE_LENGTH = 32768;
 var injectCode = defineAction({
   name: "page.injectCode",
-  description: "Install a small toolkit of JavaScript functions into the page, to be called later with page.runCode. Reach for it only when the ordinary tools are the wrong shape: a step sequence you are about to repeat three or more times with different inputs (create 20 tags, delete every row), or a capability no tool covers (seek a video, read a canvas, drive a bespoke editor API). The user reviews and approves the code before it runs \u2014 one approval covers every later page.runCode call and survives page reloads, so batch work needs no further prompts. The toolkit is bound to the tab and origin it was approved on; navigating to another site voids it. Installing goes through Chrome\u2019s debugger, so the browser shows a \u201CBrowsentic is debugging this browser\u201D bar for the moment it takes, it cannot install on a tab that has DevTools open, and it is unavailable on Firefox \u2014 the calls afterwards are cheap and show nothing. For a one-off click or fill, the ordinary tools are always the better choice.",
+  chromiumOnly: true,
+  description: "Install a small toolkit of JavaScript functions into the page, to be called later with page.runCode. Reach for it only when the ordinary tools are the wrong shape: a step sequence you are about to repeat three or more times with different inputs (create 20 tags, delete every row), or a capability no tool covers (seek a video, read a canvas, drive a bespoke editor API). The user reviews and approves the code before it runs \u2014 one approval covers every later page.runCode call and survives page reloads, so batch work needs no further prompts. The toolkit is bound to the tab and origin it was approved on; navigating to another site voids it. Installing goes through Chrome\u2019s debugger, so the browser shows a \u201CBrowsentic is debugging this browser\u201D bar for the moment it takes, and it cannot install on a tab that has DevTools open \u2014 the calls afterwards are cheap and show nothing. For a one-off click or fill, the ordinary tools are always the better choice.",
   input: external_exports.object({
     purpose: external_exports.string().min(1).max(200).describe(
       "One plain sentence saying what this toolkit does and why it is needed \u2014 shown to the user on the approval prompt, so write it for them, not for the page."
@@ -28996,6 +29006,7 @@ var MAX_LIMIT = 200;
 // ../lib/actions/page/read-console.ts
 var readConsole = defineAction({
   name: "page.readConsole",
+  chromiumOnly: true,
   description: 'Read the console messages and uncaught exceptions a page has reported since page.startDiagnostics \u2014 level, text, the file and line that logged it, and a stack for errors. Newest last. Start with level "error" before reading everything: a busy page logs constantly and only some of it is the fault.',
   input: external_exports.object({
     contains: external_exports.string().max(200).optional().describe('Case-insensitive substring the message must contain, e.g. "TypeError" or a component name'),
@@ -29012,6 +29023,7 @@ var readConsole = defineAction({
 // ../lib/actions/page/read-network.ts
 var readNetwork = defineAction({
   name: "page.readNetwork",
+  chromiumOnly: true,
   description: 'Read the requests a page has made since page.startDiagnostics \u2014 method, URL, status, resource type, timing and size, and the browser\u2019s own error text for the ones that failed. Newest last. This is how a button that \u201Cdid nothing\u201D turns into a 500 or a CORS refusal. Start with status "problems" \u2014 a page makes hundreds of requests and a handful of them are the story. Credentials in headers, URLs and bodies are sealed before they leave the browser, and response bodies are refused unless the user has allowed them.',
   input: external_exports.object({
     diagnosticsId: external_exports.string().optional().describe("Which recording to read, from page.startDiagnostics. Omit when only one is running."),
@@ -29297,6 +29309,7 @@ function parseReply(detail) {
 // ../lib/actions/page/run-code.ts
 var runCode = defineAction({
   name: "page.runCode",
+  chromiumOnly: true,
   description: "Call one function from the toolkit page.injectCode installed in this tab, with fresh arguments. This is the cheap, repeatable half of the pair: the user approved the code once, so every call runs without another prompt, and a page reload re-installs the approved toolkit on its own. It refuses if nothing is installed here, or if the tab has moved to a different site than the one the code was approved on \u2014 inject again in either case. The function\u2019s return value comes back as JSON.",
   input: external_exports.object({
     function: external_exports.string().min(1).describe("Name of a function the installed toolkit assigned onto `tools`."),
@@ -29311,6 +29324,7 @@ var runCode = defineAction({
 });
 
 // ../lib/actions/page/screenshot.ts
+var DEFAULT_LONG_SIDE = 1600;
 var screenshot = defineAction({
   name: "page.screenshot",
   description: "Capture the tab as a JPEG/PNG image \u2014 the current viewport by default, or the full scroll view, or a single targeted element. The viewport capture is the fast one: it is a single grab that returns in well under a second. fullPage: true has to scroll the page in viewport-sized steps and wait out the browser\u2019s capture rate limit between each, so it costs a second or more per screenful \u2014 ask for it only when you need what is below the fold. Nothing is written to disk unless you pass save: true \u2014 the image comes back in the result either way, so a capture you take to look at the page for yourself leaves no file behind.",
@@ -29323,15 +29337,15 @@ var screenshot = defineAction({
       "Image format. JPEG (the default) is far smaller and quicker to encode; PNG is lossless and keeps transparency, at several times the size and time."
     ),
     quality: external_exports.number().int().min(1).max(100).optional().describe('JPEG quality, 1\u2013100, defaulting to 80. Only valid when format is "jpeg".'),
-    maxLongSide: external_exports.number().int().positive().default(1600).describe(
-      "Downscale the result so its longest side is at most this many pixels. The default is sized for reading a page, not for pixel-level inspection \u2014 raise it when fine detail matters."
+    maxLongSide: external_exports.number().int().positive().optional().describe(
+      'Downscale the result so its longest side is at most this many pixels. Left out, a viewport capture you take to look at comes back at the page\u2019s own CSS-pixel size \u2014 one image pixel per page pixel, so a position in the picture is a usable "point" \u2014 and anything else, a saved capture included, is capped at 1600. That is sized for reading a page, not for pixel-level inspection: raise it when fine detail matters.'
     ),
     save: external_exports.boolean().default(false).describe(
       "Write the image to ~/browsentic/screenshot/ and report the path as savedTo. Off by default: a capture you take to see the page for yourself is handed to you in the result and should leave nothing behind. Set true only when the user asked for a picture they can keep."
     ),
     filename: external_exports.string().optional().describe("Base filename when saving; defaults to screenshot-<timestamp>.<ext>. Sanitized before use.")
   }),
-  execute({ target, fullPage, format: format2, quality, maxLongSide }) {
+  execute({ target, fullPage, format: format2, quality, maxLongSide, save }) {
     if (quality !== void 0 && format2 !== "jpeg") {
       throw new ActionError('"quality" only applies when format is "jpeg"', "INVALID_INPUT");
     }
@@ -29356,7 +29370,8 @@ var screenshot = defineAction({
       region = { x: Math.round(window.scrollX), y: Math.round(window.scrollY), w: viewport2.w, h: viewport2.h };
     }
     const scroll = { x: Math.round(window.scrollX), y: Math.round(window.scrollY) };
-    return { mode, dpr, viewport: viewport2, page, region, scroll, format: format2, quality, maxLongSide };
+    const longSide = maxLongSide ?? (mode === "viewport" && !save ? Math.min(DEFAULT_LONG_SIDE, Math.max(viewport2.w, viewport2.h)) : DEFAULT_LONG_SIDE);
+    return { mode, dpr, viewport: viewport2, page, region, scroll, format: format2, quality, maxLongSide: longSide };
   }
 });
 
@@ -29580,6 +29595,7 @@ function pointAt(segments, offset) {
 // ../lib/actions/page/solve-captcha.ts
 var solveCaptcha = defineAction({
   name: "page.solveCaptcha",
+  chromiumOnly: true,
   description: 'Tick a captcha\u2019s \u201CI am a human\u201D checkbox with a real browser-level click and wait for the widget to settle. Works where an ordinary click cannot reach: the checkbox lives inside a closed shadow root inside a cross-origin iframe, and it only responds to genuine pointer input. Returns state "solved" when the widget accepted it. When the vendor escalates to a challenge a person has to answer \u2014 an image grid, Arkose, AWS WAF \u2014 it returns state "needsHuman" with the widget bounds and does not attempt the challenge; screenshot that region, tell the user it needs them, and poll page.findCaptcha until they are done. State "invisible" means a scoring captcha with nothing to click. Chrome only, shows the debugger bar while it runs, and it is gated for approval because it acts on another site\u2019s security control.',
   input: external_exports.object({
     waitMs: external_exports.number().int().min(0).max(12e4).default(2e4).describe("How long to wait after clicking for the widget to report a verdict."),
@@ -29593,6 +29609,7 @@ var solveCaptcha = defineAction({
 // ../lib/actions/page/start-diagnostics.ts
 var startDiagnostics = defineAction({
   name: "page.startDiagnostics",
+  chromiumOnly: true,
   description: "Start recording what a page reports rather than what it shows \u2014 console messages, uncaught exceptions and every request the tab makes. Console and network events only exist while Chrome\u2019s debugger is attached, so this has to be running before the thing you are diagnosing happens: start it, then reload or click, then read. Chrome shows a \u201CBrowsentic is debugging this browser\u201D bar for as long as it runs, and attaching fails while DevTools is open on that tab. Read what it collected with page.readConsole and page.readNetwork, and end it with page.stopDiagnostics. Inside a Browsentic side-panel conversation a recording belongs to the turn that started it and detaches when that turn ends, so start it, cause the problem and read it in one go. Chrome only.",
   input: external_exports.object({
     capture: external_exports.array(external_exports.enum(["console", "network"])).default(["console", "network"]).describe("What to record. Narrow it to one when the other would only add noise."),
@@ -29667,6 +29684,7 @@ var startTimer = defineAction({
 // ../lib/actions/page/stop-diagnostics.ts
 var stopDiagnostics = defineAction({
   name: "page.stopDiagnostics",
+  chromiumOnly: true,
   description: "Detach the debugger and take Chrome\u2019s \u201CBrowsentic is debugging this browser\u201D bar away. What was collected stays readable by page.readConsole and page.readNetwork afterwards, minus response bodies, which only exist while attached. Call this as soon as you have what you need rather than leaving the bar up.",
   input: external_exports.object({
     diagnosticsId: external_exports.string().optional().describe("Omit when only one recording is running; with several running an omitted id stops nothing and the candidates are listed.")
@@ -29758,7 +29776,8 @@ var timerStatus = defineAction({
 // ../lib/actions/page/trusted-click.ts
 var trustedClick = defineAction({
   name: "page.trustedClick",
-  description: 'Click with a real browser-level mouse event \u2014 isTrusted is true, exactly as if the user had clicked. The pointer travels to the target over a short path and dwells before pressing, so widgets that only react after genuine pointer movement (drag handles, hover menus, canvas tools, captcha checkboxes) see the sequence they wait for. Use it when page.clickElement was ignored: pages that check event.isTrusted, and the browser features only a genuine gesture unlocks \u2014 native file pickers, fullscreen, clipboard reads, popups, WebAuthn prompts. Give it either a "target" or a raw viewport "point". It attaches Chrome\u2019s debugger for the duration, so the browser shows a \u201CBrowsentic is debugging this browser\u201D bar while it runs, it cannot run on a tab that has DevTools open, and it is unavailable on Firefox. page.clickElement stays the default for ordinary clicks.',
+  description: 'Click with a real browser-level mouse event \u2014 isTrusted is true, exactly as if the user had clicked. The pointer travels to the target over a short path and dwells before pressing, so widgets that only react after genuine pointer movement (drag handles, hover menus, canvas tools, captcha checkboxes) see the sequence they wait for. Use it when page.clickElement was ignored: pages that check event.isTrusted, and the browser features only a genuine gesture unlocks \u2014 native file pickers, fullscreen, clipboard reads, popups, WebAuthn prompts. Give it either a "target" or a raw viewport "point". It attaches Chrome\u2019s debugger for the duration, so the browser shows a \u201CBrowsentic is debugging this browser\u201D bar while it runs, and it cannot run on a tab that has DevTools open. page.clickElement stays the default for ordinary clicks.',
+  chromiumOnly: true,
   input: external_exports.object({
     target: targetSchema.optional().describe('Element to click. Give this or "point", never both.'),
     point: pointSchema.optional().describe(
@@ -30051,16 +30070,25 @@ var actions = new Map(
     readRecording
   ].map((action) => [action.name, action])
 );
-function describeActions() {
-  return [...actions.values()].map(({ name, description, input: input2 }) => ({
+function describeActions(target = "chromium") {
+  return [...actions.values()].filter((action) => target === "chromium" || !action.chromiumOnly).map(({ name, description, input: input2 }) => ({
     name,
     description,
-    inputSchema: external_exports.toJSONSchema(input2, { io: "input" })
+    inputSchema: tidy(external_exports.toJSONSchema(input2, { io: "input" }))
   }));
 }
+var UNBOUNDED = /* @__PURE__ */ new Set([Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER]);
+function tidy(schema) {
+  if (Array.isArray(schema)) return schema.map(tidy);
+  if (!schema || typeof schema !== "object") return schema;
+  return Object.fromEntries(
+    Object.entries(schema).filter(([key, value]) => key !== "$schema" && !(isBound(key) && UNBOUNDED.has(value))).map(([key, value]) => [key, tidy(value)])
+  );
+}
+var isBound = (key) => key === "minimum" || key === "maximum";
 
 // ../lib/agents/catalog.ts
-var AGENT_KINDS = ["claude", "codex", "antigravity"];
+var AGENT_KINDS = ["claude", "codex", "antigravity", "vibe", "grok"];
 var DEFAULT_AGENT = "claude";
 var AGENTS = {
   claude: {
@@ -30079,7 +30107,7 @@ var AGENTS = {
     bin: "codex",
     install: "npm i -g @openai/codex",
     docs: "https://developers.openai.com/codex/cli",
-    models: ["gpt-5.6-terra", "gpt-5.1-codex-max", "gpt-5.1-codex", "gpt-5.1-codex-mini"]
+    models: ["gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5"]
   },
   antigravity: {
     kind: "antigravity",
@@ -30089,6 +30117,26 @@ var AGENTS = {
     install: "https://antigravity.google/docs/cli/install",
     docs: "https://antigravity.google/docs/cli",
     models: ["gemini-3-pro", "gemini-3-flash"]
+  },
+  vibe: {
+    kind: "vibe",
+    label: "Mistral Vibe",
+    vendor: "Mistral AI",
+    bin: "vibe",
+    install: "uv tool install mistral-vibe",
+    docs: "https://github.com/mistralai/mistral-vibe",
+    models: ["mistral-medium-3.5"],
+    beta: true
+  },
+  grok: {
+    kind: "grok",
+    label: "Grok Build",
+    vendor: "xAI",
+    bin: "grok",
+    install: "curl -fsSL https://x.ai/cli/install.sh | bash",
+    docs: "https://docs.x.ai/build/overview",
+    models: ["grok-4.7"],
+    beta: true
   }
 };
 var AGENT_LIST = AGENT_KINDS.map((kind) => AGENTS[kind]);
@@ -30116,6 +30164,7 @@ var TOOL_NAME = /^[a-zA-Z0-9_-]{1,64}$/;
 function toolNameFor(actionName) {
   return actionName.replaceAll(".", "_");
 }
+var STATUS_TOOL = toolNameFor(`${RESERVED_PREFIX}status`);
 function actionNameFor(toolName) {
   return toolName.replace("_", ".");
 }
@@ -30141,12 +30190,12 @@ function assertToolNamesRoundTrip(actionNames) {
 }
 
 // cli.ts
-import { basename as basename3, join as join18 } from "path";
+import { basename as basename3, join as join20 } from "path";
 
 // agent/agent-skills.ts
 import { createHash } from "crypto";
 import { readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { join as join10, sep } from "path";
+import { join as join12, sep } from "path";
 
 // ../lib/skills/format.ts
 var MAX_BODY_BYTES = 32 * 1024;
@@ -30246,7 +30295,7 @@ function format(detail) {
 
 // agent/runners/index.ts
 import { spawn } from "child_process";
-import { dirname as dirname3, join as join8 } from "path";
+import { dirname as dirname3, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // agent/config.ts
@@ -30306,9 +30355,9 @@ function writeAgentModel(kind, model) {
   if (kind === "claude") delete next.model;
   write(next);
 }
-function write(config2) {
+function write(config4) {
   mkdirSync3(stateDir, { recursive: true, mode: 448 });
-  writeFileSync2(configPath, `${JSON.stringify(config2, null, 2)}
+  writeFileSync2(configPath, `${JSON.stringify(config4, null, 2)}
 `, { mode: 384 });
 }
 function rememberExtensionDir(dir) {
@@ -30437,14 +30486,14 @@ var claudeRunner = {
     };
   },
   reader() {
+    let prompt = 0;
     let generated = 0;
+    let counted = false;
+    const promptOf = (usage) => (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
     const report = (usage, sink) => {
-      if (!usage) return;
+      counted = true;
       generated += usage.output_tokens ?? 0;
-      sink.usage({
-        contextTokens: (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.output_tokens ?? 0),
-        outputTokens: generated
-      });
+      sink.usage({ contextTokens: prompt + (usage.output_tokens ?? 0), outputTokens: generated });
     };
     return (line, sink) => {
       const message = parseJsonLine(line);
@@ -30467,16 +30516,18 @@ var claudeRunner = {
             const name = event.content_block.name ?? "tool";
             if (WEB_TOOLS.includes(name)) sink.tool(event.content_block.id ?? randomUUID(), name);
           }
+          if (event?.type === "message_start") prompt = promptOf(event.message?.usage ?? {});
+          if (event?.type === "message_delta" && event.usage) report(event.usage, sink);
           return;
         }
-        case "assistant":
-          if (!message.parent_tool_use_id) report(message.message?.usage, sink);
-          return;
         case "result":
           if (message.is_error) {
             return sink.fail("AGENT_FAILED", message.result || message.subtype || "Claude Code reported an error");
           }
-          if (!generated) report(message.usage, sink);
+          if (!counted && message.usage) {
+            prompt = promptOf(message.usage);
+            report(message.usage, sink);
+          }
           return sink.done(message.stop_reason || "end_turn");
       }
     };
@@ -30721,12 +30772,12 @@ var ownTool = (name) => /browsentic|^mcp/i.test(name);
 import { randomUUID as randomUUID3 } from "crypto";
 import { homedir as homedir4 } from "os";
 import { join as join7 } from "path";
-var SANDBOX = ["--sandbox", "read-only", "--ask-for-approval", "never", "--skip-git-repo-check"];
+var SANDBOX = ["-c", 'sandbox_mode="read-only"', "-c", 'approval_policy="never"', "--skip-git-repo-check"];
 var WEB_TOOL = "web_search";
 var codexRunner = {
   kind: "codex",
   versionArgs: ["--version"],
-  efforts: ["minimal", "low", "medium", "high"],
+  efforts: ["low", "medium", "high", "xhigh"],
   workspace: () => stateDir,
   skillDirs: () => [join7(homedir4(), ".codex", "skills"), join7(homedir4(), ".codex", "prompts")],
   stream(context) {
@@ -30749,6 +30800,9 @@ var codexRunner = {
         `${server}.env=${tomlTable(mcp.env)}`,
         "-c",
         `${server}.required=true`,
+        // Headless Codex refuses an MCP call it would have asked about; the daemon gates these tools itself.
+        "-c",
+        `${server}.default_tools_approval_mode="approve"`,
         "-c",
         `developer_instructions=${tomlString(context.systemPrompt)}`,
         "-c",
@@ -30801,7 +30855,7 @@ var codexRunner = {
           case "task_complete":
             return sink.done("end_turn");
           case "error":
-            return sink.fail("AGENT_FAILED", msg.error || msg.message || "Codex reported an error");
+            return sink.fail("AGENT_FAILED", explain(msg.error || msg.message) || "Codex reported an error");
           default:
             return;
         }
@@ -30832,9 +30886,9 @@ var codexRunner = {
           return sink.done("end_turn");
         }
         case "turn.failed":
-          return sink.fail("AGENT_FAILED", frame.error?.message || "Codex could not finish the turn");
+          return sink.fail("AGENT_FAILED", explain(frame.error?.message) || "Codex could not finish the turn");
         case "error":
-          return sink.fail("AGENT_FAILED", frame.message || frame.error?.message || "Codex reported an error");
+          return sink.fail("AGENT_FAILED", explain(frame.message || frame.error?.message) || "Codex reported an error");
         default:
           return;
       }
@@ -30890,6 +30944,11 @@ var codexRunner = {
     return null;
   }
 };
+function explain(raw) {
+  if (!raw) return raw;
+  const message = parseJsonLine(raw)?.error?.message ?? raw;
+  return /model .*(not supported|does not exist|not found)/i.test(message) ? `${message} Pick another model for Codex in the Browsentic popup, then try again.` : message;
+}
 function kindOf(item) {
   return item?.type ?? item?.item_type;
 }
@@ -30897,30 +30956,367 @@ var tomlString = (value) => JSON.stringify(value);
 var tomlArray = (values) => `[${values.map(tomlString).join(",")}]`;
 var tomlTable = (values) => `{${Object.entries(values).map(([key, value]) => `${key}=${tomlString(value)}`).join(",")}}`;
 
+// agent/runners/grok.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join8 } from "path";
+var CONFIG = ".grok/config.toml";
+var INERT = "todo_write";
+var WEB_TOOLS2 = ["web_search", "web_fetch"];
+var READ_TOOL = "read_file";
+var SEARCH_TOOL = "search_tool";
+var USE_TOOL = "use_tool";
+var OFFERED = [SEARCH_TOOL, USE_TOOL, INERT, ...WEB_TOOLS2];
+var DENIED = ["Bash", "Edit", "Write"];
+var SEALED = { GROK_MEMORY: "0", GROK_CLAUDE_MCPS_ENABLED: "false", GROK_CURSOR_MCPS_ENABLED: "false" };
+var TRUSTED = { GROK_FOLDER_TRUST: "0" };
+var TOOL_NAMES = `Browsentic's tools are on the MCP server named ${MCP_SERVER_NAME}. Call them with ${USE_TOOL}, prefixing each name with "${MCP_SERVER_NAME}__": page_getPageInfo is ${MCP_SERVER_NAME}__page_getPageInfo.`;
+var grokHome = () => process.env.GROK_HOME || join8(homedir5(), ".grok");
+var grokRunner = {
+  kind: "grok",
+  versionArgs: ["--version"],
+  efforts: ["low", "medium", "high", "xhigh"],
+  workspace: (mode) => join8(stateDir, "agents", "grok", mode),
+  skillDirs: () => [join8(grokHome(), "skills"), join8(homedir5(), ".agents", "skills"), join8(homedir5(), ".claude", "skills")],
+  stream(context) {
+    const { settings, research } = context;
+    const effort = effortOf(settings, this.efforts);
+    const base = this.workspace("run");
+    sweepRunDirs(base);
+    const conversation = context.sessionId ?? randomUUID4();
+    return {
+      cwd: join8(base, conversation.replace(/[^\w-]/g, "_")),
+      env: { BROWSENTIC_AGENT_RUN: context.runId, ...SEALED, ...TRUSTED },
+      files: [{ path: CONFIG, content: config2(context.mcp) }],
+      args: [
+        "-p",
+        context.instruction,
+        "--output-format",
+        "streaming-json",
+        "--permission-mode",
+        "dontAsk",
+        "--allow",
+        `MCPTool(${MCP_SERVER_NAME}__*)`,
+        "--tools",
+        (research ? WEB_TOOLS2 : [INERT]).join(","),
+        ...denying([...DENIED, "Read"]),
+        "--no-subagents",
+        "--sandbox",
+        "workspace",
+        "--rules",
+        `${context.systemPrompt.trim()}
+
+${TOOL_NAMES}`,
+        ...context.sessionId ? ["--resume", context.sessionId] : ["--session-id", conversation],
+        ...settings.model ? ["--model", settings.model] : [],
+        ...effort ? ["--reasoning-effort", effort] : []
+      ]
+    };
+  },
+  reader() {
+    const reported = /* @__PURE__ */ new Set();
+    let said = false;
+    let turned = false;
+    let counted = false;
+    let generated = 0;
+    const report = (usage, sink) => {
+      counted = true;
+      generated += usage.output_tokens ?? 0;
+      sink.usage({
+        contextTokens: (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.output_tokens ?? 0),
+        outputTokens: generated
+      });
+    };
+    return (line, sink) => {
+      const event = parseJsonLine(line);
+      if (!event) return;
+      switch (event.type) {
+        case "available_commands": {
+          const unexpected = (event.tools ?? []).filter((tool) => !OFFERED.includes(tool));
+          if (!unexpected.length) return;
+          return sink.fail(
+            "AGENT_UNSAFE",
+            `Grok Build offered this run ${unexpected.join(", ")}, which Browsentic never asks for, so the run was stopped before the model saw them. Update Grok Build and Browsentic; if it persists, please report it.`
+          );
+        }
+        case "text":
+          if (!event.data) return;
+          sink.text(said && turned ? `
+
+${event.data}` : event.data);
+          said = true;
+          turned = false;
+          return;
+        case "tool_call": {
+          turned = true;
+          const id = event.toolCallId;
+          const name = toolOf(event);
+          if (!id || !name || reported.has(id)) return;
+          reported.add(id);
+          if (name !== SEARCH_TOOL && !ownTool2(name)) sink.tool(id, name);
+          return;
+        }
+        case "usage":
+          turned = true;
+          if (event.usage) report(event.usage, sink);
+          return;
+        case "end":
+          if (event.sessionId) sink.session(event.sessionId);
+          if (!counted && event.usage) report(event.usage, sink);
+          return sink.done(event.stopReason || "end_turn");
+        case "error":
+          return sink.fail("AGENT_FAILED", explain2(event.message) ?? "Grok Build reported an error");
+        default:
+          return;
+      }
+    };
+  },
+  json(context) {
+    const { settings } = context;
+    const effort = effortOf(settings, this.efforts);
+    return {
+      cwd: this.workspace("task"),
+      env: { ...SEALED },
+      args: [
+        "-p",
+        context.prompt,
+        "--output-format",
+        "json",
+        "--permission-mode",
+        "dontAsk",
+        "--tools",
+        context.reads ? READ_TOOL : INERT,
+        ...denying(["MCPTool", ...DENIED]),
+        "--no-subagents",
+        "--sandbox",
+        "read-only",
+        ...settings.model ? ["--model", settings.model] : [],
+        ...effort ? ["--reasoning-effort", effort] : []
+      ]
+    };
+  },
+  answer(stdout) {
+    const answer = lastLine(stdout);
+    if (answer?.type === "error") return { error: explain2(answer.message) ?? "Grok Build reported an error" };
+    return { text: answer?.text };
+  },
+  hint(stderrTail) {
+    const error51 = /^Error: ([\s\S]+)/m.exec(stderrTail)?.[1]?.trim();
+    if (error51) return explain2(error51) ?? null;
+    if (/unexpected argument|unrecognized|invalid value/i.test(stderrTail)) {
+      return `Your Grok Build does not understand the flags Browsentic uses. Run "grok update", then try again. (${stderrTail.trim()})`;
+    }
+    return null;
+  },
+  async check() {
+    if (process.env.XAI_API_KEY || existsSync2(join8(grokHome(), "auth.json"))) return null;
+    return {
+      code: "AGENT_NEEDS_PERMISSION",
+      message: "Grok Build is installed but not signed in.",
+      fix: "grok login"
+    };
+  }
+};
+var denying = (rules) => rules.flatMap((rule) => ["--deny", rule]);
+var ownTool2 = (name) => name.startsWith(`${MCP_SERVER_NAME}__`);
+function toolOf(event) {
+  if (event.toolName !== USE_TOOL) return event.toolName;
+  return event.rawInput ? event.rawInput.tool_name ?? USE_TOOL : void 0;
+}
+function explain2(message) {
+  if (!message) return message;
+  if (/not signed in/i.test(message)) {
+    return 'Grok Build is installed but not signed in. Run "grok login", or set XAI_API_KEY, then try again.';
+  }
+  if (/unknown model id|couldn't set model/i.test(message)) {
+    return `${sentence(message)} Pick another model for Grok Build in the Browsentic popup, then try again.`;
+  }
+  if (/unknown effort level/i.test(message)) {
+    return `${sentence(message)} Pick another effort for Grok Build in the Browsentic popup, then try again.`;
+  }
+  if (/resource has been exhausted|requests too quickly/i.test(message)) {
+    return `xAI is rate-limiting this Grok account. Wait a few minutes and try again, or upgrade at https://grok.com/supergrok. (${oneLine(message)})`;
+  }
+  if (/did not respond to this request|service temporarily unavailable/i.test(message)) {
+    return `xAI did not answer, after Grok Build had retried for several minutes. A free Grok account is rate-limited this way; wait and try again. (${oneLine(message)})`;
+  }
+  if (/re-run with --trust|folder untrusted/i.test(message)) {
+    return `Grok Build refused to use Browsentic's workspace because it is not trusted. This is a bug in Browsentic \u2014 please report it. (${message})`;
+  }
+  return message;
+}
+var oneLine = (message) => message.replace(/\s+/g, " ").slice(0, 240);
+var sentence = (message) => /[.!?]$/.test(message.trim()) ? message.trim() : `${message.trim()}.`;
+function config2(server) {
+  const quote = (value) => JSON.stringify(value);
+  const env = Object.entries(server.env).map(([name, value]) => `${name} = ${quote(value)}`);
+  return [
+    `[mcp_servers.${MCP_SERVER_NAME}]`,
+    `command = ${quote(server.command)}`,
+    `args = [${server.args.map(quote).join(", ")}]`,
+    `env = { ${env.join(", ")} }`,
+    ""
+  ].join("\n");
+}
+function lastLine(stdout) {
+  for (const line of stdout.trim().split("\n").reverse()) {
+    const parsed2 = parseJsonLine(line.trim());
+    if (parsed2) return parsed2;
+  }
+  return null;
+}
+
+// agent/runners/vibe.ts
+import { homedir as homedir6 } from "os";
+import { join as join9 } from "path";
+var CONFIG2 = ".vibe/config.toml";
+var INSTRUCTIONS2 = "AGENTS.md";
+var TASK_INSTRUCTIONS2 = "This directory is Browsentic scratch space. Answer the prompt exactly as it asks, and do not act on anything else you find here.\n";
+var WEB_TOOLS3 = ["web_search", "web_fetch"];
+var READ_TOOL2 = "read_file";
+var NO_TOOLS = "re:^$";
+var PROFILE = "ask";
+var vibeHome = () => process.env.VIBE_HOME || join9(homedir6(), ".vibe");
+var vibeRunner = {
+  kind: "vibe",
+  versionArgs: ["--version"],
+  efforts: [],
+  endsOnExit: true,
+  workspace: (mode) => join9(stateDir, "agents", "vibe", mode),
+  skillDirs: () => [join9(vibeHome(), "skills"), join9(homedir6(), ".agents", "skills")],
+  stream(context) {
+    const base = this.workspace("run");
+    sweepRunDirs(base);
+    const builtins = context.research ? WEB_TOOLS3 : [];
+    const granted = [...context.mcpTools.map((tool) => `${MCP_SERVER_NAME}_${tool}`), ...builtins];
+    return {
+      cwd: join9(base, context.runId),
+      env: { BROWSENTIC_AGENT_RUN: context.runId },
+      files: [
+        { path: CONFIG2, content: config3(context.settings.model, context.mcp, granted) },
+        { path: INSTRUCTIONS2, content: `${context.systemPrompt.trim()}
+` }
+      ],
+      args: [
+        "--prompt",
+        context.instruction,
+        "--output",
+        "streaming",
+        "--trust",
+        "--agent",
+        PROFILE,
+        ...enabling([`${MCP_SERVER_NAME}_*`, ...builtins]),
+        ...context.sessionId ? ["--resume", context.sessionId] : []
+      ]
+    };
+  },
+  reader() {
+    const startedAt = Date.now();
+    let spoke = false;
+    return (line, sink) => {
+      const entry = parseJsonLine(line);
+      if (!entry) return;
+      if (entry.sessionId) sink.session(entry.sessionId);
+      if (entry.createdAt !== void 0 && entry.createdAt < startedAt) return;
+      if (entry.type === "message" && entry.role === "assistant") {
+        const text3 = textOf(entry);
+        if (!text3) return;
+        sink.text(spoke ? `
+
+${text3}` : text3);
+        spoke = true;
+        return;
+      }
+      const tool = entry.type === "effect" ? entry.detail?.toolName : void 0;
+      if (tool && entry.id && !ownTool3(tool)) sink.tool(entry.id, tool);
+    };
+  },
+  json(context) {
+    const allowed = context.reads ? [READ_TOOL2] : [];
+    return {
+      cwd: this.workspace("task"),
+      files: [
+        { path: CONFIG2, content: config3(context.settings.model, null, allowed) },
+        { path: INSTRUCTIONS2, content: TASK_INSTRUCTIONS2 }
+      ],
+      args: [
+        "--prompt",
+        context.prompt,
+        "--output",
+        "json",
+        "--trust",
+        "--agent",
+        PROFILE,
+        ...enabling(allowed.length ? allowed : [NO_TOOLS])
+      ]
+    };
+  },
+  answer(stdout) {
+    const parsed2 = parseJsonLine(stdout.trim());
+    const history2 = Array.isArray(parsed2) ? parsed2 : parsed2?.history ?? [];
+    const last = history2.findLast((entry) => entry.type === "message" && entry.role === "assistant" && textOf(entry));
+    return { text: last ? textOf(last) : void 0 };
+  },
+  hint(stderrTail) {
+    if (/Missing \w+ environment variable/i.test(stderrTail)) {
+      return `Mistral Vibe is installed but has no API key. Run "vibe --setup", or put MISTRAL_API_KEY in ${join9(vibeHome(), ".env")}, then try again. (${stderrTail.trim()})`;
+    }
+    if (/unrecognized arguments|invalid choice/i.test(stderrTail)) {
+      return `Your Mistral Vibe does not understand the flags Browsentic uses. Update it, then try again. (${stderrTail.trim()})`;
+    }
+    return null;
+  }
+};
+var enabling = (patterns) => patterns.flatMap((pattern) => ["--enabled-tools", pattern]);
+var textOf = (entry) => (entry.content ?? []).filter((block) => block.type === "text" && block.text).map((block) => block.text).join("\n\n");
+var ownTool3 = (name) => name.startsWith(`${MCP_SERVER_NAME}_`);
+function config3(model, server, granted) {
+  const quote = (value) => JSON.stringify(value);
+  const lines = model ? [`active_model = ${quote(model)}`, ""] : [];
+  if (server) {
+    lines.push(
+      "[[mcp_servers]]",
+      `name = ${quote(MCP_SERVER_NAME)}`,
+      'transport = "stdio"',
+      `command = [${quote(server.command)}]`,
+      `args = [${server.args.map(quote).join(", ")}]`,
+      "",
+      "[mcp_servers.env]",
+      ...Object.entries(server.env).map(([name, value]) => `${name} = ${quote(value)}`),
+      ""
+    );
+  }
+  for (const tool of granted) lines.push(`[tools.${quote(tool)}]`, 'permission = "always"', "");
+  return lines.join("\n");
+}
+
 // agent/runners/index.ts
 var RUNNERS = {
   claude: claudeRunner,
   codex: codexRunner,
-  antigravity: antigravityRunner
+  antigravity: antigravityRunner,
+  vibe: vibeRunner,
+  grok: grokRunner
 };
-var cliPath = join8(dirname3(fileURLToPath2(import.meta.url)), "cli.js");
+var cliPath = join10(dirname3(fileURLToPath2(import.meta.url)), "cli.js");
 
 // agent/skills.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4, readdirSync as readdirSync2 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname4, isAbsolute, join as join9 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync as readdirSync2 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname4, isAbsolute, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var bundledDir = join9(dirname4(fileURLToPath3(import.meta.url)), "..", "skills");
-var userDir2 = join9(stateDir, "skills");
+var bundledDir = join11(dirname4(fileURLToPath3(import.meta.url)), "..", "skills");
+var userDir2 = join11(stateDir, "skills");
 function uploadedSkillsDir() {
   const configured = readAgentConfig().skillsDir;
   if (typeof configured === "string" && configured.trim()) return expandHome(configured.trim());
-  return join9(homedir5(), "browsentic", "skills");
+  return join11(homedir7(), "browsentic", "skills");
 }
 function expandHome(p) {
-  if (p === "~") return homedir5();
-  if (p.startsWith("~/")) return join9(homedir5(), p.slice(2));
-  return isAbsolute(p) ? p : join9(homedir5(), p);
+  if (p === "~") return homedir7();
+  if (p.startsWith("~/")) return join11(homedir7(), p.slice(2));
+  return isAbsolute(p) ? p : join11(homedir7(), p);
 }
 function skillDirs() {
   return [
@@ -30946,7 +31342,7 @@ function readDir(dir, source) {
   try {
     const entries = readdirSync2(dir, { withFileTypes: true }).filter((entry) => !entry.name.startsWith("."));
     files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name);
-    directories = entries.filter((entry) => entry.isDirectory() && existsSync2(join9(dir, entry.name, SKILL_FILE))).map((entry) => entry.name);
+    directories = entries.filter((entry) => entry.isDirectory() && existsSync3(join11(dir, entry.name, SKILL_FILE))).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -30957,9 +31353,9 @@ function readDir(dir, source) {
       log(`skill "${name}" exists as both ${name}.md and ${name}/${SKILL_FILE} in ${dir}; using the file`);
       continue;
     }
-    push(join9(dir, name, SKILL_FILE), name);
+    push(join11(dir, name, SKILL_FILE), name);
   }
-  for (const file2 of files) push(join9(dir, file2), file2.replace(/\.md$/, ""));
+  for (const file2 of files) push(join11(dir, file2), file2.replace(/\.md$/, ""));
   return skills;
   function push(path, fallbackName) {
     try {
@@ -31000,8 +31396,8 @@ var MAX_SKILL_BYTES = 48 * 1024;
 var TTL_MS = 3e4;
 var cached2 = null;
 var known = /* @__PURE__ */ new Map();
-function agentSkills(config2, { refresh = false } = {}) {
-  const agent = config2.agent;
+function agentSkills(config4, { refresh = false } = {}) {
+  const agent = config4.agent;
   const dirs = RUNNERS[agent].skillDirs?.() ?? [];
   const signature = dirs.join("\n");
   if (!refresh && cached2 && cached2.agent === agent && cached2.dirs === signature && Date.now() - cached2.at < TTL_MS) {
@@ -31028,7 +31424,7 @@ function scan(dir, agent, out) {
     return;
   }
   for (const entry of entries) {
-    const path = entry.name.endsWith(".md") ? join10(dir, entry.name) : join10(dir, entry.name, SKILL_FILE);
+    const path = entry.name.endsWith(".md") ? join12(dir, entry.name) : join12(dir, entry.name, SKILL_FILE);
     try {
       const stats = statSync3(path);
       if (!stats.isFile() || stats.size > MAX_SKILL_BYTES) continue;
@@ -31054,8 +31450,8 @@ function idOf(path) {
 
 // agent/approvals.ts
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join11 } from "path";
-var approvalsPath = join11(stateDir, "approvals.json");
+import { join as join13 } from "path";
+var approvalsPath = join13(stateDir, "approvals.json");
 function read() {
   try {
     const parsed2 = JSON.parse(readFileSync6(approvalsPath, "utf8"));
@@ -31084,11 +31480,11 @@ function forgetGrants(host) {
 }
 
 // downloads.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import {
   chmodSync as chmodSync3,
   copyFileSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync7,
   renameSync as renameSync2,
@@ -31097,8 +31493,8 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync5
 } from "fs";
-import { homedir as homedir6 } from "os";
-import { basename, isAbsolute as isAbsolute2, join as join12 } from "path";
+import { homedir as homedir8 } from "os";
+import { basename, isAbsolute as isAbsolute2, join as join14 } from "path";
 
 // ../lib/downloads/limits.ts
 var MAX_DOWNLOAD_BYTES = 100 * 1024 * 1024;
@@ -31542,8 +31938,8 @@ var DEFAULT_FENCE = {
   // image-specific renderer instead.
   except: ["page.closeTab", "page.stopMonitor", "page.screenshot"]
 };
-function policyFrom(config2 = {}, requireApproval = [SUBMIT_ACTION]) {
-  const overrides = config2.rules ?? {};
+function policyFrom(config4 = {}, requireApproval = [SUBMIT_ACTION]) {
+  const overrides = config4.rules ?? {};
   const rules = DEFAULT_RULES.map((rule) => {
     const legacy = rule.id === "form-submission" && !requireApproval.includes(SUBMIT_ACTION) ? "allow" : rule.effect;
     return { ...rule, effect: overrides[rule.id] ?? legacy };
@@ -31551,9 +31947,9 @@ function policyFrom(config2 = {}, requireApproval = [SUBMIT_ACTION]) {
   return {
     rules,
     requireApproval,
-    unattended: config2.unattended === "allow" ? "allow" : "deny",
-    urlPayloadBytes: typeof config2.urlPayloadBytes === "number" && config2.urlPayloadBytes >= 0 ? config2.urlPayloadBytes : DEFAULT_URL_PAYLOAD_BYTES,
-    fence: config2.fence === false ? { ...DEFAULT_FENCE, enabled: false } : DEFAULT_FENCE
+    unattended: config4.unattended === "allow" ? "allow" : "deny",
+    urlPayloadBytes: typeof config4.urlPayloadBytes === "number" && config4.urlPayloadBytes >= 0 ? config4.urlPayloadBytes : DEFAULT_URL_PAYLOAD_BYTES,
+    fence: config4.fence === false ? { ...DEFAULT_FENCE, enabled: false } : DEFAULT_FENCE
   };
 }
 var POLICY = policyFrom();
@@ -31598,6 +31994,7 @@ var RULE_IDS = new Set(DEFAULT_RULES.map((rule) => rule.id));
 
 // guardrails/spawn.ts
 var NEVER2 = ["Bash", "Edit", "Write", "NotebookEdit", "Glob", "Grep", "Task"];
+var GROK_SEALED = { GROK_MEMORY: "0", GROK_CLAUDE_MCPS_ENABLED: "false", GROK_CURSOR_MCPS_ENABLED: "false" };
 var CONTAINMENT = {
   claude: {
     localTools: "allowlist",
@@ -31629,19 +32026,13 @@ var CONTAINMENT = {
     keepsEnv: ["OPENAI_", "CODEX_", "AZURE_OPENAI_"],
     note: "no per-run tool list; the read-only sandbox is the whole containment, so the agent can still read any file the user can",
     run: {
-      required: [],
-      pairs: [
-        ["--sandbox", "read-only"],
-        ["--ask-for-approval", "never"]
-      ],
+      required: ['sandbox_mode="read-only"', 'approval_policy="never"'],
+      pairs: [],
       files: []
     },
     task: {
-      required: ["mcp_servers={}"],
-      pairs: [
-        ["--sandbox", "read-only"],
-        ["--ask-for-approval", "never"]
-      ],
+      required: ['sandbox_mode="read-only"', 'approval_policy="never"', "mcp_servers={}"],
+      pairs: [],
       files: []
     }
   },
@@ -31659,20 +32050,68 @@ var CONTAINMENT = {
       pairs: [],
       files: [".agents/mcp_config.json", "AGENTS.md"]
     }
+  },
+  vibe: {
+    localTools: "allowlist",
+    keepsEnv: ["MISTRAL_", "VIBE_"],
+    note: "per-run tool allowlist; the shell and file tools are never loaded, and approvals follow a config Browsentic writes",
+    run: {
+      required: ["--trust"],
+      pairs: [["--agent", "ask"]],
+      allows: { flag: "--enabled-tools", only: ["browsentic_*", "web_search", "web_fetch"] },
+      files: [".vibe/config.toml", "AGENTS.md"]
+    },
+    task: {
+      required: ["--trust"],
+      pairs: [["--agent", "ask"]],
+      // A one-shot reaches no browser: nothing but the scratch-file reader, or a pattern that matches no tool.
+      allows: { flag: "--enabled-tools", only: ["read_file", "re:^$"] },
+      files: [".vibe/config.toml", "AGENTS.md"]
+    }
+  },
+  grok: {
+    localTools: "allowlist",
+    keepsEnv: ["XAI_", "GROK_"],
+    note: "per-run built-in tool list, approvals that refuse whatever was not granted up front, and a kernel sandbox that keeps writes in its own directory; reads are closed by the tool list and a Read deny rather than the sandbox, and MCP servers the user gave Grok itself still load",
+    run: {
+      required: ["--no-subagents"],
+      // `--always-approve` would be the headless default; dontAsk runs only what was allowed.
+      pairs: [
+        ["--permission-mode", "dontAsk"],
+        ["--sandbox", "workspace"]
+      ],
+      // Deny beats every allow Grok merges in, including the user's Claude Code rules.
+      denies: { flag: "--deny", tools: ["Bash", "Edit", "Write", "Read"] },
+      allows: { flag: "--tools", only: ["todo_write", "web_search", "web_fetch"] },
+      env: GROK_SEALED,
+      files: [".grok/config.toml"]
+    },
+    task: {
+      required: ["--no-subagents"],
+      pairs: [
+        ["--permission-mode", "dontAsk"],
+        ["--sandbox", "read-only"]
+      ],
+      // A bare MCPTool refuses every MCP call, from whichever server the user configured.
+      denies: { flag: "--deny", tools: ["MCPTool", "Bash", "Edit", "Write"] },
+      allows: { flag: "--tools", only: ["todo_write", "read_file"] },
+      env: GROK_SEALED,
+      files: []
+    }
   }
 };
 
 // downloads.ts
-var indexPath = join12(stateDir, "downloads.json");
+var indexPath = join14(stateDir, "downloads.json");
 function downloadDir() {
   const configured = readAgentConfig().downloadDir;
   if (typeof configured === "string" && configured.trim()) return expandHome2(configured.trim());
-  return join12(homedir6(), "browsentic", "download");
+  return join14(homedir8(), "browsentic", "download");
 }
 function expandHome2(p) {
-  if (p === "~") return homedir6();
-  if (p.startsWith("~/")) return join12(homedir6(), p.slice(2));
-  return isAbsolute2(p) ? p : join12(homedir6(), p);
+  if (p === "~") return homedir8();
+  if (p.startsWith("~/")) return join14(homedir8(), p.slice(2));
+  return isAbsolute2(p) ? p : join14(homedir8(), p);
 }
 function readIndex() {
   try {
@@ -31704,21 +32143,34 @@ function clearDownloads() {
   return records.length;
 }
 function storedDownloads() {
-  return readIndex().filter((record2) => existsSync3(record2.savedTo));
+  return readIndex().filter((record2) => existsSync4(record2.savedTo));
 }
 var HEAD_BYTES = 64 * 1024;
 
 // ensure-daemon.ts
 import { spawn as spawn2 } from "child_process";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname5, join as join13 } from "path";
+import { dirname as dirname5, join as join15 } from "path";
+
+// ports.ts
+var daemonPorts = parsePorts(process.env.BROWSENTIC_PORTS) ?? DAEMON_PORTS;
+function parsePorts(value) {
+  if (!value) return null;
+  const ports = value.split(",").map((port) => Number(port.trim()));
+  if (ports.some((port) => !Number.isInteger(port) || port < 0 || port > 65535)) {
+    throw new Error(`BROWSENTIC_PORTS must be a comma-separated list of ports, not "${value}"`);
+  }
+  return ports;
+}
+
+// ensure-daemon.ts
 var SPAWN_TIMEOUT_MS = 8e3;
 var POLL_INTERVAL_MS = 150;
 async function ensureDaemon() {
   const existing = await probeExisting();
   if (existing) return existing;
   log("no daemon reachable; spawning one");
-  const daemonMain = join13(dirname5(fileURLToPath4(import.meta.url)), "daemon-main.js");
+  const daemonMain = join15(dirname5(fileURLToPath4(import.meta.url)), "daemon-main.js");
   const env = { ...process.env };
   delete env.BROWSENTIC_AGENT_RUN;
   delete env.CLAUDECODE;
@@ -31740,7 +32192,7 @@ async function ensureDaemon() {
 async function probeExisting() {
   const lock = readLockfile();
   if (lock && isRunning(lock.pid) && await healthyPid(lock.port) === lock.pid) return lock;
-  for (const port of DAEMON_PORTS) {
+  for (const port of daemonPorts) {
     if (port === lock?.port) continue;
     const pid = await healthyPid(port);
     if (pid === null) continue;
@@ -31751,7 +32203,7 @@ async function probeExisting() {
 }
 async function runningDaemons() {
   const found = /* @__PURE__ */ new Map();
-  for (const port of DAEMON_PORTS) {
+  for (const port of daemonPorts) {
     const pid = await healthyPid(port);
     if (pid !== null && !found.has(pid)) found.set(pid, port);
   }
@@ -31801,7 +32253,7 @@ function delay(ms) {
 import { createHash as createHash2 } from "crypto";
 import {
   chmodSync as chmodSync4,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync8,
   readdirSync as readdirSync4,
@@ -31810,10 +32262,10 @@ import {
   statSync as statSync5,
   writeFileSync as writeFileSync6
 } from "fs";
-import { join as join14, relative } from "path";
+import { join as join16, relative } from "path";
 function walk(dir, base = dir) {
   return readdirSync4(dir, { withFileTypes: true }).flatMap((entry) => {
-    const full = join14(dir, entry.name);
+    const full = join16(dir, entry.name);
     return entry.isDirectory() ? walk(full, base) : [relative(base, full)];
   });
 }
@@ -31848,10 +32300,10 @@ function install(dir, force = false) {
       "Reinstall with `npm i -g browsentic`, or run `yarn build` if you are in a source checkout."
     );
   }
-  const manifestPath = join14(packaged.dir, "manifest.json");
+  const manifestPath = join16(packaged.dir, "manifest.json");
   const version2 = JSON.parse(readFileSync8(manifestPath, "utf8")).version;
   const stamp = readStamp(dir);
-  if (!force && stamp?.version === version2 && existsSync4(manifestPath)) {
+  if (!force && stamp?.version === version2 && existsSync5(manifestPath)) {
     return {
       dir,
       version: version2,
@@ -31864,15 +32316,15 @@ function install(dir, force = false) {
   const sources = walk(packaged.dir);
   mkdirSync7(dir, { recursive: true, mode: 493 });
   for (const stale of walk(dir).filter((f) => /\.tmp-\d+$/.test(f))) {
-    rmSync4(join14(dir, stale), { force: true });
+    rmSync4(join16(dir, stale), { force: true });
   }
   const ordered = [...sources.filter((f) => f !== "manifest.json"), "manifest.json"];
   let changed = 0;
   for (const rel of ordered) {
-    const from = join14(packaged.dir, rel);
-    const to = join14(dir, rel);
+    const from = join16(packaged.dir, rel);
+    const to = join16(dir, rel);
     if (!force && sameContent(from, to)) continue;
-    mkdirSync7(join14(to, ".."), { recursive: true, mode: 493 });
+    mkdirSync7(join16(to, ".."), { recursive: true, mode: 493 });
     const tmp = `${to}.tmp-${process.pid}`;
     try {
       writeFileSync6(tmp, readFileSync8(from), { mode: 420 });
@@ -31894,7 +32346,7 @@ function install(dir, force = false) {
   const wanted = new Set(sources);
   for (const rel of walk(dir)) {
     if (wanted.has(rel) || rel === ".browsentic-install.json") continue;
-    rmSync4(join14(dir, rel), { force: true });
+    rmSync4(join16(dir, rel), { force: true });
   }
   const record2 = {
     version: version2,
@@ -31908,17 +32360,17 @@ function install(dir, force = false) {
 }
 
 // npx.ts
-import { existsSync as existsSync5, readFileSync as readFileSync9, readdirSync as readdirSync5, realpathSync } from "fs";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname6, join as join15, resolve, sep as sep2 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync9, readdirSync as readdirSync5, realpathSync } from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname6, join as join17, resolve, sep as sep2 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var packageRoot = resolve(dirname6(fileURLToPath5(import.meta.url)), "..");
 var APP_MARKER = ".browsentic-app.json";
 var inNpxCache = (path) => path.split(sep2).includes("_npx");
 function installKind() {
   if (inNpxCache(packageRoot)) return "npx";
-  if (existsSync5(join15(packageRoot, APP_MARKER))) return "app";
-  if (existsSync5(join15(packageRoot, "tsup.config.ts"))) return "repo";
+  if (existsSync6(join17(packageRoot, APP_MARKER))) return "app";
+  if (existsSync6(join17(packageRoot, "tsup.config.ts"))) return "repo";
   return "global";
 }
 function real(path) {
@@ -31931,10 +32383,10 @@ function real(path) {
 function cacheRoots() {
   const roots = [
     process.env.npm_config_cache,
-    process.platform === "win32" ? join15(process.env.LOCALAPPDATA ?? homedir7(), "npm-cache") : null,
-    join15(homedir7(), ".npm")
+    process.platform === "win32" ? join17(process.env.LOCALAPPDATA ?? homedir9(), "npm-cache") : null,
+    join17(homedir9(), ".npm")
   ].filter((root) => !!root);
-  return [...new Set(roots.map((root) => join15(root, "_npx")))];
+  return [...new Set(roots.map((root) => join17(root, "_npx")))];
 }
 function readJson(path) {
   try {
@@ -31947,7 +32399,7 @@ function npxEntries() {
   const own = inNpxCache(packageRoot) ? real(resolve(packageRoot, "..", "..")) : null;
   const scanned = cacheRoots().flatMap((root) => {
     try {
-      return readdirSync5(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => real(join15(root, entry.name)));
+      return readdirSync5(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => real(join17(root, entry.name)));
     } catch {
       return [];
     }
@@ -31955,9 +32407,9 @@ function npxEntries() {
   const entries = /* @__PURE__ */ new Map();
   for (const dir of [...scanned, ...own ? [own] : []]) {
     if (entries.has(dir)) continue;
-    const manifest = readJson(join15(dir, "node_modules", "browsentic", "package.json"));
+    const manifest = readJson(join17(dir, "node_modules", "browsentic", "package.json"));
     if (!manifest) continue;
-    const requested = readJson(join15(dir, "package.json"))?._npx;
+    const requested = readJson(join17(dir, "package.json"))?._npx;
     entries.set(dir, {
       dir,
       version: typeof manifest.version === "string" ? manifest.version : null,
@@ -31974,8 +32426,23 @@ function pinnedVersion() {
   return requested && /^\d+\.\d+\.\d+/.test(requested) ? requested : null;
 }
 
+// firefox-addon.ts
+var RELEASES = process.env.BROWSENTIC_RELEASES ?? "https://github.com/imshaikot/browsentic/releases";
+var RELEASES_PAGE = `${RELEASES}/latest`;
+function signedAddonUrl(version2) {
+  return `${RELEASES}/download/v${version2}/browsentic-${version2}-firefox.xpi`;
+}
+async function signedAddonAttached(version2, timeoutMs = 4e3) {
+  try {
+    const response = await fetch(signedAddonUrl(version2), { method: "HEAD", signal: AbortSignal.timeout(timeoutMs) });
+    return response.ok;
+  } catch {
+    return null;
+  }
+}
+
 // remote-bridge.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // node_modules/ws/wrapper.mjs
 var import_stream2 = __toESM(require_stream(), 1);
@@ -32009,38 +32476,40 @@ var RemoteBridge = class _RemoteBridge {
     });
   }
   async describe() {
-    const reply = await this.request({ id: randomUUID5(), op: "describe" });
-    return reply && "tools" in reply ? reply.tools : [];
+    const reply = await this.request({ id: randomUUID6(), op: "describe", runId: this.runId });
+    return reply && "tools" in reply ? { tools: reply.tools, reserved: reply.reserved } : { tools: [] };
   }
   async invoke(action, input2) {
     const reply = await this.request(
-      { id: randomUUID5(), op: "invoke", action, input: input2, runId: this.runId },
+      { id: randomUUID6(), op: "invoke", action, input: input2, runId: this.runId },
       invokeTimeoutFor(action, input2)
     );
     if (reply && "result" in reply) return reply.result;
     return failure("DAEMON_UNREACHABLE", "The Browsentic daemon did not respond");
   }
   async status() {
-    const reply = await this.request({ id: randomUUID5(), op: "status" });
+    const reply = await this.request({ id: randomUUID6(), op: "status" });
     if (reply && "status" in reply) return reply.status;
     throw new Error("The Browsentic daemon did not respond to a status request");
   }
   async pair() {
-    const reply = await this.request({ id: randomUUID5(), op: "pair" });
+    const reply = await this.request({ id: randomUUID6(), op: "pair" });
     if (reply && "code" in reply) return reply;
     throw new Error("The Browsentic daemon did not issue a pairing code");
   }
   async sessions() {
-    const reply = await this.request({ id: randomUUID5(), op: "sessions" });
+    const reply = await this.request({ id: randomUUID6(), op: "sessions" });
     return reply && "sessions" in reply ? reply.sessions : [];
   }
   async agent(change) {
-    const reply = await this.request({ id: randomUUID5(), op: "agent", ...change });
+    const reply = await this.request({ id: randomUUID6(), op: "agent", ...change });
     if (reply && "state" in reply) return reply.state;
     throw new Error("The Browsentic daemon did not answer about its agent");
   }
-  async revoke(origin) {
-    const reply = await this.request({ id: randomUUID5(), op: "revoke", origin });
+  /** A browser is named by its session id; an origin still unpairs every browser presenting it. */
+  async revoke(browser) {
+    const named = browser?.includes("://") ? { origin: browser } : { session: browser };
+    const reply = await this.request({ id: randomUUID6(), op: "revoke", ...named });
     return reply && "revoked" in reply ? reply.revoked : 0;
   }
   onManifestChanged(listener) {
@@ -33916,7 +34385,6 @@ var Server = class extends Protocol {
 };
 
 // server.ts
-var STATUS_TOOL = toolNameFor(`${RESERVED_PREFIX}status`);
 var SCREENSHOT_TOOL = "page_screenshot";
 var PICK_TOOL = "page_pickElement";
 var FOCUS_SHOT_TOOL = {
@@ -33928,7 +34396,7 @@ var RESOURCES = [
   {
     uri: "browsentic://page/current",
     name: "Active page snapshot",
-    description: "Full page.getPageInfo snapshot of the active tab: metadata, layout tree, headings, interactive inventory.",
+    description: "Full page.getPageInfo snapshot of the active tab: metadata, layout diagram, headings, interactive inventory.",
     mimeType: "application/json"
   },
   {
@@ -34012,6 +34480,10 @@ var SAVE_SITE_MAP_TOOL = {
     }
   }
 };
+var RESERVED_TOOLS = [
+  { action: SAVE_SITE_MAP_ACTION, descriptor: SAVE_SITE_MAP_TOOL },
+  { action: FOCUS_SHOT_ACTION, descriptor: FOCUS_SHOT_TOOL }
+];
 function createMcpServer(bridge, version2, opts = {}) {
   const policy = policyFrom(readAgentConfig().guardrails);
   const tag2 = fenceTag();
@@ -34023,7 +34495,7 @@ function createMcpServer(bridge, version2, opts = {}) {
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const actions2 = await bridge.describe();
+    const { tools: actions2, reserved = opts.agentRun ? RESERVED_TOOLS.map((tool) => tool.action) : [] } = await bridge.describe();
     assertToolNamesRoundTrip([...actions2.map((action) => action.name), ...RESERVED_ACTIONS]);
     return {
       tools: [
@@ -34037,7 +34509,7 @@ function createMcpServer(bridge, version2, opts = {}) {
           description: "Report whether the Browsentic browser extension is connected, its version, and the active tab. Use this first if a page tool fails.",
           inputSchema: { type: "object", properties: {}, additionalProperties: false }
         },
-        ...opts.agentRun ? [SAVE_SITE_MAP_TOOL, FOCUS_SHOT_TOOL] : []
+        ...RESERVED_TOOLS.filter((tool) => reserved.includes(tool.action)).map((tool) => tool.descriptor)
       ]
     };
   });
@@ -34163,7 +34635,7 @@ function splitDataUrl(dataUrl) {
 }
 function render(result, fenceWith) {
   if (result.ok) {
-    const body = sealSecrets(JSON.stringify(result.data, null, 2));
+    const body = sealSecrets(JSON.stringify(result.data));
     return { content: [{ type: "text", text: fenceWith ? fence(body, fenceWith) : body }] };
   }
   return {
@@ -34180,23 +34652,23 @@ function text2(uri, mimeType, body) {
 }
 
 // uninstall.ts
-import { existsSync as existsSync6, readdirSync as readdirSync6, rmSync as rmSync6 } from "fs";
-import { isAbsolute as isAbsolute4, join as join17, relative as relative2 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync6, rmSync as rmSync6 } from "fs";
+import { isAbsolute as isAbsolute4, join as join19, relative as relative2 } from "path";
 
 // screenshots.ts
 import { randomBytes as randomBytes3 } from "crypto";
 import { chmodSync as chmodSync5, mkdirSync as mkdirSync8, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir8 } from "os";
-import { basename as basename2, isAbsolute as isAbsolute3, join as join16, resolve as resolve2, sep as sep3 } from "path";
+import { homedir as homedir10 } from "os";
+import { basename as basename2, isAbsolute as isAbsolute3, join as join18, resolve as resolve2, sep as sep3 } from "path";
 function screenshotDir() {
   const configured = readAgentConfig().screenshotDir;
   if (typeof configured === "string" && configured.trim()) return expandHome3(configured.trim());
-  return join16(homedir8(), "browsentic", "screenshot");
+  return join18(homedir10(), "browsentic", "screenshot");
 }
 function expandHome3(p) {
-  if (p === "~") return homedir8();
-  if (p.startsWith("~/")) return join16(homedir8(), p.slice(2));
-  return isAbsolute3(p) ? p : join16(homedir8(), p);
+  if (p === "~") return homedir10();
+  if (p.startsWith("~/")) return join18(homedir10(), p.slice(2));
+  return isAbsolute3(p) ? p : join18(homedir10(), p);
 }
 
 // uninstall.ts
@@ -34205,11 +34677,11 @@ function contains(root, path) {
   return !inside.startsWith("..") && !isAbsolute4(inside);
 }
 function planUninstall(options = {}) {
-  const config2 = readAgentConfig();
-  const extension2 = extensionDir(config2.extensionDir);
+  const config4 = readAgentConfig();
+  const extension2 = extensionDir(config4.extensionDir);
   const roots = [stateDir, userDir];
   const removals = [];
-  if (!roots.some((root) => contains(root, extension2)) && existsSync6(extension2)) {
+  if (!roots.some((root) => contains(root, extension2)) && existsSync7(extension2)) {
     removals.push({ label: "extension", path: extension2, holds: "the unpacked build Chrome loads" });
   }
   removals.push({
@@ -34226,13 +34698,13 @@ function planUninstall(options = {}) {
   });
   const elsewhere = [];
   const outside = (label2, path, holds) => {
-    if (!roots.some((root) => contains(root, path)) && existsSync6(path)) elsewhere.push({ label: label2, path, holds });
+    if (!roots.some((root) => contains(root, path)) && existsSync7(path)) elsewhere.push({ label: label2, path, holds });
   };
   outside("skills", uploadedSkillsDir(), "site maps and uploaded skills");
   outside("screenshots", screenshotDir(), "captures taken with save: true");
   outside("downloads", downloadDir(), "files captured from pages");
   return {
-    removals: removals.filter((removal) => existsSync6(removal.path)),
+    removals: removals.filter((removal) => existsSync7(removal.path)),
     elsewhere,
     npx: npxEntries()
   };
@@ -34252,7 +34724,7 @@ function keepingSome(dir, keep) {
   const kept = [];
   for (const entry of readdirSync6(dir)) {
     if (keep.includes(entry)) kept.push(entry);
-    else rmSync6(join17(dir, entry), { recursive: true, force: true });
+    else rmSync6(join19(dir, entry), { recursive: true, force: true });
   }
   return kept;
 }
@@ -34270,7 +34742,7 @@ function purgeNpxCache(entries) {
 // package.json
 var package_default = {
   name: "browsentic",
-  version: "0.6.0",
+  version: "0.7.0",
   description: "A browser extension with an AI side panel that hands your real, logged-in browser to the AI agent you already run. Installs the extension, runs the local daemon, and optionally speaks MCP.",
   type: "module",
   license: "MIT",
@@ -34331,15 +34803,16 @@ var package_default = {
 var USAGE = `browsentic ${package_default.version} \u2014 hand your real browser to the agent you already run
 
   browsentic setup            install the extension, start the daemon, print a pairing code
+                              --browser firefox: link the signed add-on instead of installing a folder
   browsentic update           pull the newest build \u2014 the command itself, then the extension
   browsentic uninstall        stop the daemon and remove everything Browsentic wrote
   browsentic pair             issue a one-time code to type into the extension
   browsentic status           daemon, extension and agent state
   browsentic sessions         list paired browsers
-  browsentic revoke [origin]  unpair one browser, or all of them
+  browsentic revoke [id]      unpair one browser by the id "sessions" prints, or all of them
 
   browsentic agent            show which agent runs the side panel, and which are installed
-  browsentic agent <name>     switch to claude, codex or antigravity
+  browsentic agent <name>     switch to claude, codex, antigravity, vibe or grok
   browsentic agent fix <name> let Browsentic fix what that agent still needs
   browsentic agent model <name> [model]   pin that agent's model, or omit it for the CLI's default
 
@@ -34470,13 +34943,13 @@ function printTools() {
 function printSkills() {
   const skills = loadSkills();
   if (wantsJson) {
-    const config3 = readAgentConfig();
+    const config5 = readAgentConfig();
     const listed = skills.map(({ body: _body, ...skill }) => ({
       ...skill,
-      path: skill.provenance === "generated" ? join18(uploadedSkillsDir(), skill.name) : void 0
+      path: skill.provenance === "generated" ? join20(uploadedSkillsDir(), skill.name) : void 0
     }));
-    const own2 = agentSkills(config3).map(({ name, description }) => ({ name, description }));
-    console.log(JSON.stringify({ skills: listed, dirs: skillDirNames(), agent: config3.agent, agentSkills: own2 }, null, 2));
+    const own2 = agentSkills(config5).map(({ name, description }) => ({ name, description }));
+    console.log(JSON.stringify({ skills: listed, dirs: skillDirNames(), agent: config5.agent, agentSkills: own2 }, null, 2));
     return;
   }
   if (!skills.length) {
@@ -34494,15 +34967,15 @@ function printSkills() {
     ].filter(Boolean);
     console.log(`${skill.name}  (${tags.join(" \xB7 ")})`);
     if (skill.description) console.log(`  ${skill.description}`);
-    if (skill.provenance === "generated") console.log(`  ${join18(uploadedSkillsDir(), skill.name)}/`);
+    if (skill.provenance === "generated") console.log(`  ${join20(uploadedSkillsDir(), skill.name)}/`);
   }
   console.log(`
 Read in order: ${skillDirNames().join(" \u2192 ")} (a later one shadows an earlier one by name)`);
-  const config2 = readAgentConfig();
-  const own = agentSkills(config2);
+  const config4 = readAgentConfig();
+  const own = agentSkills(config4);
   if (own.length) {
     console.log(`
-${AGENTS[config2.agent].label}'s own skills (attachable from the panel's / picker):`);
+${AGENTS[config4.agent].label}'s own skills (attachable from the panel's / picker):`);
     for (const skill of own) {
       console.log(`${skill.name}`);
       if (skill.description) console.log(`  ${skill.description}`);
@@ -34600,28 +35073,15 @@ async function setup(argv) {
     if (code2 !== null) process.exit(code2);
   }
   const browser = valueOf("browser") ?? "chrome";
-  if (browser === "firefox") {
-    console.log(`
-  Firefox is not supported by this command yet.
-
-  Release Firefox refuses unsigned extensions, and an add-on loaded through
-  about:debugging is discarded when the browser restarts, so there is nothing
-  useful to install. A signed build distributed through addons.mozilla.org is
-  the fix, and it is not ready.
-
-  Developer Edition and Nightly can load dist/firefox-mv2 from the source
-  repository with xpinstall.signatures.required set to false.
-`);
-    process.exit(1);
-  }
-  if (browser !== "chrome") {
-    console.error(`Unknown browser "${browser}". Supported: chrome`);
+  if (browser !== "chrome" && browser !== "firefox") {
+    console.error(`Unknown browser "${browser}". Supported: chrome, firefox`);
     process.exit(1);
   }
+  const json2 = flag("json");
+  if (browser === "firefox") return setupFirefox({ json: json2, restart: flag("restart"), pair: !flag("no-pair") });
   const chosen = valueOf("dir");
   const dir = extensionDir(chosen ?? readAgentConfig().extensionDir);
   if (chosen) rememberExtensionDir(chosen);
-  const json2 = flag("json");
   let result;
   try {
     result = install(dir, flag("force"));
@@ -34663,6 +35123,8 @@ async function setup(argv) {
   if (alreadyPaired) {
     console.log(`  This browser is already paired. Press \u21BB on the Browsentic card at`);
     console.log(`  chrome://extensions to pick up this build, and you are done.
+`);
+    console.log(`  Adding another browser? Load the same folder there, then run "browsentic pair".
 `);
     return;
   }
@@ -34689,6 +35151,71 @@ async function setup(argv) {
   console.log(`  Then open the side panel and say what you want.
 `);
 }
+async function setupFirefox({ json: json2, restart: fresh, pair: pair2 }) {
+  if (fresh) await restart();
+  const lock = await ensureDaemon();
+  const bridge = await RemoteBridge.connect(lock.port, lock.token);
+  const sessions = await bridge.sessions();
+  const alreadyPaired = sessions.some((session) => session.origin.startsWith("moz-extension://"));
+  const code = alreadyPaired || !pair2 ? void 0 : (await bridge.pair()).code;
+  await bridge.close();
+  const addon = signedAddonUrl(package_default.version);
+  const attached = await signedAddonAttached(package_default.version);
+  if (json2) {
+    console.log(
+      JSON.stringify(
+        { version: package_default.version, firefoxAddon: addon, attached, daemon: { port: lock.port, pid: lock.pid }, alreadyPaired, pairingCode: code },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(`
+  Browsentic ${package_default.version}
+`);
+  console.log(`  \u2713 Daemon     127.0.0.1:${lock.port} (pid ${lock.pid})
+`);
+  if (alreadyPaired) {
+    console.log(`  This Firefox is already paired, and it picks up each new build on its own \u2014`);
+    console.log(`  about:addons \u2192 the gear \u2192 "Check for Updates" does it right now.
+`);
+    console.log(`  Adding another browser? Install the add-on there too, then run "browsentic pair".
+`);
+    return;
+  }
+  console.log(`  Firefox installs only what addons.mozilla.org has signed, so there is no folder to load.`);
+  console.log(`  Two steps are left. Both happen inside the browser, so only you can do them.
+`);
+  console.log(`  1. Open this link in Firefox:
+`);
+  console.log(`         ${addon}
+`);
+  console.log(`     It asks whether to let github.com install software, then whether to add`);
+  console.log(`     Browsentic \u2014 say yes to both. Or download it and use about:addons \u2192 the gear \u2192`);
+  console.log(`     "Install Add-on From File\u2026". Once installed, Firefox keeps it current on its own.
+`);
+  if (attached === false) {
+    console.log(`     That file is not attached to the ${package_default.version} release yet \u2014 Mozilla may still be`);
+    console.log(`     signing it. Give it a few minutes, or take the newest one from
+`);
+    console.log(`         ${RELEASES_PAGE}
+`);
+  }
+  if (code) {
+    console.log(`  2. Open the Browsentic popup and paste this code:
+`);
+    console.log(`         ${groupCode(code)}
+`);
+    console.log(`     Single use, expires in 10 minutes. Need another? "browsentic pair"
+`);
+  } else {
+    console.log(`  2. Run "browsentic pair" and paste the code into the Browsentic popup.
+`);
+  }
+  console.log(`  Then open the sidebar and say what you want.
+`);
+}
 async function uninstall(argv) {
   const flag = (name) => argv.includes(`--${name}`);
   const plan = planUninstall({ keepSkills: flag("keep-skills") });
@@ -34775,8 +35302,8 @@ async function showSessions() {
     return console.log('No paired browsers. Run "browsentic setup" to add one.');
   }
   for (const session of sessions) {
-    console.log(`${session.connected ? "\u25CF" : "\u25CB"} ${session.origin}`);
-    console.log(`    extension v${session.extensionVersion}, paired ${session.pairedAt}, last seen ${session.lastSeenAt}`);
+    console.log(`${session.connected ? "\u25CF" : "\u25CB"} ${session.browser ?? session.origin}  ${session.id}`);
+    console.log(`    ${session.origin}, extension v${session.extensionVersion}, paired ${session.pairedAt}, last seen ${session.lastSeenAt}`);
   }
 }
 async function chooseAgent(first, second, third) {
@@ -34816,11 +35343,11 @@ async function chooseAgent(first, second, third) {
   console.log(`
 The side panel runs on ${AGENTS[state.active].label}.`);
 }
-async function revoke(origin) {
+async function revoke(browser) {
   const bridge = await connect();
-  const revoked = await bridge.revoke(origin);
+  const revoked = await bridge.revoke(browser);
   await bridge.close();
-  if (!revoked) return console.log(origin ? `No session for ${origin}.` : "Nothing to revoke.");
+  if (!revoked) return console.log(browser ? `No session for ${browser}.` : "Nothing to revoke.");
   console.log(`Revoked ${revoked} session(s). Pair again with "browsentic pair".`);
 }
 async function connect() {