@capagents/forgeqe 1.1.1 → 1.1.3

package/src/capabilities/registry.ts

@@ -61,11 +61,11 @@ export const CAPABILITIES: Capability[] = [
     area: "Browser",
     title: "Run any goal in a real browser",
     summary:
-      "Carries out a plain-language goal in Chrome one step at a time and verifies the outcome, with screenshots, a report, and the steps it took. Page memory replays steps that already worked on a site, so repeat runs are faster and cheaper.",
+      "Carries out a plain-language goal in a real browser one step at a time and verifies the outcome, with screenshots, a report, and the steps it took. The browser comes from forgeqe.yaml: local Chrome or Chromium by default, or BrowserStack or TestMu AI/LambdaTest when configured. Page memory replays steps that already worked on a site, so repeat runs are faster and cheaper.",
     tools: ["browser_run", "run_details", "page_memory"],
     examples: ["Go to booking.com and search hotels in Mumbai for next weekend", "What does ForgeQE know about the checkout page?"],
     requires: [{ kind: "live_model" }],
-    limits: ["Web applications in Chrome or Chromium only: not native mobile or desktop applications."],
+    limits: ["Web applications only: local Chrome or Chromium, or configured remote web grids such as BrowserStack and TestMu AI/LambdaTest; not native mobile or desktop applications."],
     docs: [
       { doc: "HOW_TO_USE.md", heading: "4. Without the shell" },
       { doc: "HOW_TO_USE.md", heading: "5. Page memory" },
@@ -345,7 +345,7 @@ export const CAPABILITIES: Capability[] = [
  * Only add what is certain.
  */
 export const OUT_OF_SCOPE: { what: string; instead?: string }[] = [
-  { what: "Native mobile apps (iOS, Android) and desktop applications", instead: "web applications in Chrome or Chromium" },
+  { what: "Native mobile apps (iOS, Android) and desktop applications", instead: "web applications in local Chrome or Chromium, or configured remote web grids such as BrowserStack and TestMu AI/LambdaTest" },
   { what: "Load, stress, or soak testing with many simultaneous users", instead: "per-page Core Web Vitals with budgets" },
   { what: "Penetration testing or dynamic security scanning", instead: "security findings in pull request reviews" },
 ]

package/src/childEnv.ts

@@ -84,3 +84,7 @@ export function privateEnvNames(cfg: AppConfig, extra: Iterable<string> = []): s
 export function loginEnvNames(logins: { usernameEnv?: string; passwordEnv?: string; totpEnv?: string }[]): string[] {
   return logins.flatMap((l) => [l.usernameEnv, l.passwordEnv, l.totpEnv]).filter((n): n is string => Boolean(n))
 }
+
+export function browserProviderEnvNames(browser: Pick<AppConfig["browser"], "provider" | "remote">): string[] {
+  return browser.provider === "local" || !browser.remote ? [] : [browser.remote.usernameEnv, browser.remote.accessKeyEnv].filter(Boolean)
+}

package/src/cli/help.ts

@@ -17,23 +17,31 @@ Usage:
                  [--repo DIR] [--no-code]
   forgeqe run "<request>" [--profile name] [--url URL] [--headed] [--plain] [--max-steps N]
                [--repo DIR] [--no-code] [--replay MODE] [--no-memory] [--attempts N] [--code-model provider/model]
+               [--browser-provider local|browserstack|testmu]
                                                ForgeQE's agent works out what the request needs: a browser goal,
                                                test cases from Jira, Azure DevOps, Xray or files, a test, a pipeline
-  forgeqe run --direct "<goal>" [--out DIR] [--skill NAME] ...  one browser goal, no agent
+  forgeqe run --direct "<goal>" [--out DIR] [--skill NAME] [--browser-provider local|browserstack|testmu] ...  one browser goal, no agent
   forgeqe suite <source...> [--parallel N] [--repo DIR] [--no-code] [--no-write-back] [--out DIR]
                  [--profile name] [--url URL] [--headed] [--plain] [--attempts N] [--skill NAME]
+                 [--browser-provider local|browserstack|testmu]
                                                run test cases the same way every time (what pipelines call)
   forgeqe cases <source...> [--goal]          list the test cases a source gives (--goal: the goal each runs)
   forgeqe code [run-dir] [--repo DIR] [--attempts N] [--code-model provider/model]
                                                write a test for a run (default: the latest) with Scribe
   forgeqe heal ["<test command>"] [--repo DIR] [--attempts N] [--code-model provider/model] [--headed] [--plain]
+                [--browser-provider local|browserstack|testmu]
                                                run the repo's tests and heal the ones the app has outgrown
   forgeqe monitor [source...] [--every 15m] [--once] [--replay MODE] [--parallel N] [--out DIR] [--verbose] [--skill NAME]
+                  [--browser-provider local|browserstack|testmu]
                                                check flows on a schedule and alert Teams or email when one breaks
   forgeqe monitor --test-alerts               send a sample alert to check the Teams and email settings
-  forgeqe mcp [--repo DIR] [--profile name] [--url URL] [--headed]
+  forgeqe mcp [--repo DIR] [--profile name] [--url URL] [--headed] [--browser-provider local|browserstack|testmu]
                                                ForgeQE's tools as an MCP server on stdio, for other agents
   forgeqe mcp list                            the Azure DevOps, Jira and other MCP servers ForgeQE's agent gets
+  forgeqe bi [build] [--evidence-dir DIR] [--data-dir DIR] [--build-dir DIR]
+                                               export ForgeQE + ADO/Jira datasets into an Evidence project and build static BI HTML
+  forgeqe bi init                             scaffold or refresh the managed Evidence project files
+  forgeqe bi sync                             refresh the CSV datasets and generated Evidence pages, without building
   forgeqe pr-tests [pr] [--base BRANCH] [--agent] [--run] [--post]
                                                the tests a pull request (or the commits since BRANCH) can break; --run runs
                                                them and exits 1 when one fails (a CI gate), --post puts the results on the PR
@@ -48,6 +56,7 @@ Usage:
   forgeqe visual approve [run-dir] [--page a,b] [--yes]
                                                make the run's screenshots the new baselines (an intended change)
   forgeqe explore <story> [--url URL] [--charters N] [--roles a,b] [--focus TEXT] [--yes] [--file-bugs]
+                         [--browser-provider local|browserstack|testmu]
                                                exploratory testing of a story (ado:123, SHOP-12, a link, or its text):
                                                charters beyond the scripted cases, defects confirmed by a second run,
                                                proposed test cases, bugs for confirmed defects; exits 1 on a defect
@@ -67,8 +76,8 @@ Usage:
   forgeqe api tests [SET] --scenarios[=a,b] --repo DIR
                                                scenario tests on the repository's existing API helpers
   forgeqe api list                            saved contract sets
-  forgeqe auth login [system] [--no-browser]  sign in to azure_devops, github, jira, confluence, testrail, zephyr, qtest
-                                               or xray in the browser, and save the token in the system's credential store
+  forgeqe auth login [system] [--no-browser]  sign in to azure_devops, github, jira, confluence, testrail, zephyr, qtest,
+                                               xray, browserstack, or testmu in the browser, and save the token in the system's credential store
   forgeqe auth login <ENV_NAME>               save one secret (an LLM API key, a webhook URL) in the credential store
   forgeqe auth [status]                       which systems are signed in, and how
   forgeqe auth logout <system|ENV_NAME>       forget a saved sign-in
@@ -100,6 +109,7 @@ page with ranked locators and a confidence %, plus the steps of each goal's last
 --replay verify   replay a known goal without the LLM, then one LLM step checks the result (default)
 --replay trust    replay and finish without the LLM when every step works
 --replay off      never replay; still record pages
+--browser-provider  pick which configured browser provider runs this command's browser work
 
 ForgeQE's agent (forgeqe start, forgeqe run) runs on the agent runtime with the active profile's model (or code.model) and
 calls ForgeQE's tools: browser runs, reading and running test cases, writing tests and running them, page memory, pushing
@@ -127,6 +137,10 @@ With sources.bugs, each failed case files a bug in Jira or Azure DevOps, or comm
 The report is report.html (step verdicts, timeline with screenshots, timings, environment) + junit.xml in
 out/suites/<time>/; every run folder also has its own report.html.
 
+Static BI (bi: in forgeqe.yaml): \`forgeqe bi\` writes curated CSV datasets from ForgeQE's own suite and readiness
+reports plus optional Azure DevOps WIQL and Jira JQL datasets, scaffolds an Evidence project, and runs
+\`evidence build\` to produce static HTML in the build directory. No server stays up between runs.
+
 Healing (forgeqe heal): ForgeQE runs the tests (the command given, code.test_command, or one the agent finds).
 For each failing test, Scribe re-runs its flow in the real browser: when the flow still works, the test is out
 of date and it updates the steps and locators from page memory; when the browser fails at the same step, it is an

package/src/cli/index.ts

@@ -10,7 +10,7 @@ import { goalFor, loadCases } from "../cases/index.ts"
 import { codeSkipReason, latestRunDir, runCodeAgent } from "../code/index.ts"
 import { detailFrom } from "../detail.ts"
 import { ensureOpencode, INSTALL_HINT } from "../code/runtime.ts"
-import { loadConfig, parseDuration, replayMode, selectProfile, userConfigDir, type AppConfig } from "../config.ts"
+import { browserProvider, loadConfig, parseDuration, replayMode, selectProfile, userConfigDir, type AppConfig, type BrowserProvider } from "../config.ts"
 import { runHeal } from "../heal/loop.ts"
 import { formatHeal } from "../heal/report.ts"
 import { backgroundMonitors, stopBackgroundMonitors } from "../monitor/background.ts"
@@ -44,6 +44,8 @@ import { resultsCard, runSelection, selectionCard } from "../code/find.ts"
 import { listSets as listApiSets } from "../api/store.ts"
 import { builtinPrompt, lineDiff, listPrompts, prompt, promptDirs, promptFile, promptWarnings } from "../prompts.ts"
 import { steScore, STE_TARGET } from "../ste.ts"
+import { checkStyle, promptKind, PROMPT_KINDS, RFC_TARGET } from "../promptstyle.ts"
+import { BUILTIN_CASES, loadPromptCases, previousRates, runCase, saveResults, type CaseResult } from "../evals/prompts.ts"
 import { resultsMarkdown, selectPrTests } from "../code/prtests.ts"
 import { postPrComment, resolvePr } from "../code/prreview.ts"
 import { privateEnvNames } from "../childEnv.ts"
@@ -52,13 +54,19 @@ import { featuresText } from "../capabilities/render.ts"
 import { DOMAIN_CASES, gate, loadDomainCases, reportMarkdown, runDomainEval, saveReport, VARIANTS, type Variant } from "../evals/domain.ts"
 import { evalNotice, notifiedLine, notify, notifySuite } from "../notify/events.ts"
 import { sendNotice, type Notice } from "../notify/notice.ts"
+import { buildBi, initBiProject, syncBiData } from "../bi.ts"
 
 const AGENT_COMMANDS = new Set(["start", "run", "code", "suite", "heal", "monitor", "explore"])
-const LOGGED_COMMANDS = new Set([...AGENT_COMMANDS, "mcp", "login", "setup"])
+const LOGGED_COMMANDS = new Set([...AGENT_COMMANDS, "mcp", "login", "setup", "bi"])
 
 /** How much of the agents' work to print: brief unless --verbose. */
 const detailOf = (flags: Flags) => detailFrom(boolFlag(flags, "verbose"))
 
+function browserProviderFlag(flags: Flags): BrowserProvider | undefined {
+  const value = strFlag(flags, "browser-provider")
+  return value ? browserProvider(value) : undefined
+}
+
 function debugRequested(flags: Flags): boolean {
   return boolFlag(flags, "debug") || /^(1|true|yes|on)$/i.test(process.env.FORGEQE_DEBUG || "")
 }
@@ -184,8 +192,10 @@ export async function main(argv: string[]): Promise<number> {
         return await withUsageLine(() => cmdApi(positionals.slice(1), flags))
       case "explore":
         return await withUsageLine(() => cmdExplore(positionals.slice(1), flags))
+      case "bi":
+        return await cmdBi(positionals.slice(1), flags)
       case "prompts":
-        return cmdPrompts(positionals.slice(1), flags)
+        return positionals[1] === "eval" ? await withUsageLine(() => cmdPromptEval(positionals.slice(2), flags)) : cmdPrompts(positionals.slice(1), flags)
       case "eval":
         return await withUsageLine(() => cmdEval(positionals.slice(1), flags))
       case "notify":
@@ -207,7 +217,7 @@ export async function main(argv: string[]): Promise<number> {
         const cfg = loadConfig(configOpts(flags))
         const trends = positionals[1] === "trends"
         const color = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR
-        const ctx: ToolContext = { config: cfg, cwd: process.cwd(), session: "once", emit: toolPrinter(color, (line) => console.log(line), detailOf(flags)) }
+    const ctx: ToolContext = { config: cfg, cwd: process.cwd(), session: "once", emit: toolPrinter(color, (line) => console.log(line), detailOf(flags)) }
         const out = (await TOOLS.find((t) => t.name === (trends ? "quality_trends" : "quality_report"))!.run(trends ? { page: positionals[2] } : { run_dir: positionals[1] }, ctx)) as { budget_exceeded?: unknown[]; pages?: { slower: unknown[]; newly_failing_rules: unknown[] }[] }
         return out.budget_exceeded?.length || out.pages?.some((p) => p.slower.length || p.newly_failing_rules.length) ? 1 : 0
       }
@@ -372,7 +382,7 @@ async function cmdApi(args: string[], flags: Flags): Promise<number> {
   const cfg = loadConfig(configOpts(flags))
   const action = args[0] || "list"
   const color = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR
-  const ctx: ToolContext = { config: cfg, cwd: process.cwd(), session: "once", emit: toolPrinter(color, (line) => console.log(line), detailOf(flags)) }
+    const ctx: ToolContext = { config: cfg, cwd: process.cwd(), session: "once", emit: toolPrinter(color, (line) => console.log(line), detailOf(flags)) }
   const tool = (name: string) => TOOLS.find((t) => t.name === name)!
   const csv = (name: string) => (strFlag(flags, name) || "").split(",").map((s) => s.trim()).filter(Boolean)
   switch (action) {
@@ -449,7 +459,17 @@ async function cmdExplore(args: string[], flags: Flags): Promise<number> {
   process.once("SIGINT", onSigint)
   try {
     const ask = process.stdin.isTTY && !boolFlag(flags, "yes") ? terminalAsk(controller.signal) : undefined
-    const ctx: ToolContext = { config: cfg, cwd: process.cwd(), session: "once", signal: controller.signal, headed: boolFlag(flags, "headed"), maxSteps: maxStepsFlag(flags), emit: toolPrinter(color, (line) => console.log(line), detailOf(flags)), ...(ask ? { ask } : {}) }
+    const ctx: ToolContext = {
+      config: cfg,
+      cwd: process.cwd(),
+      session: "once",
+      signal: controller.signal,
+      headed: boolFlag(flags, "headed"),
+      browserProvider: browserProviderFlag(flags),
+      maxSteps: maxStepsFlag(flags),
+      emit: toolPrinter(color, (line) => console.log(line), detailOf(flags)),
+      ...(ask ? { ask } : {}),
+    }
     const roles = (strFlag(flags, "roles") || "").split(",").map((s) => s.trim()).filter(Boolean)
     const out = (await TOOLS.find((t) => t.name === "explore_story")!.run(
       { story, url: strFlag(flags, "url"), charters: Number(strFlag(flags, "charters")) || undefined, ...(roles.length ? { roles } : {}), focus: strFlag(flags, "focus"), file_bugs: boolFlag(flags, "file-bugs") },
@@ -461,6 +481,50 @@ async function cmdExplore(args: string[], flags: Flags): Promise<number> {
   }
 }
 
+async function cmdBi(args: string[], flags: Flags): Promise<number> {
+  const cfg = loadConfig(configOpts(flags))
+  const action = args[0] || "build"
+  const overrides = {
+    evidenceDir: strFlag(flags, "evidence-dir") || strFlag(flags, "dir"),
+    dataDir: strFlag(flags, "data-dir"),
+    buildDir: strFlag(flags, "build-dir") || strFlag(flags, "out"),
+  }
+  switch (action) {
+    case "init": {
+      const out = await initBiProject(cfg, overrides)
+      console.log(`Evidence project  ${out.evidenceDir}`)
+      for (const file of out.files) console.log(`generated         ${path.relative(process.cwd(), file) || file}`)
+      return 0
+    }
+    case "sync": {
+      const out = await syncBiData(cfg, overrides)
+      console.log(`Evidence project  ${out.evidenceDir}`)
+      console.log(`Data export       ${out.dataDir}`)
+      console.log(`Build output      ${out.buildDir}`)
+      console.log(`Suite runs        ${out.suites}`)
+      console.log(`Case results      ${out.caseResults}`)
+      console.log(`Readiness reports ${out.readinessReports}`)
+      console.log(`External datasets ${out.externalDatasets}`)
+      console.log(`Summary           ${path.relative(process.cwd(), out.summaryFile) || out.summaryFile}`)
+      return 0
+    }
+    case "build": {
+      const out = await buildBi(cfg, overrides)
+      console.log(`Evidence project  ${out.evidenceDir}`)
+      console.log(`Static site       ${out.buildDir}`)
+      console.log(`Index             ${path.relative(process.cwd(), out.indexFile) || out.indexFile}`)
+      console.log(`Summary           ${path.relative(process.cwd(), out.summaryFile) || out.summaryFile}`)
+      console.log(`Suite runs        ${out.suites}`)
+      console.log(`Case results      ${out.caseResults}`)
+      console.log(`Readiness reports ${out.readinessReports}`)
+      console.log(`External datasets ${out.externalDatasets}`)
+      return 0
+    }
+    default:
+      throw new Error("Usage: forgeqe bi [init|sync|build] [--evidence-dir DIR] [--data-dir DIR] [--build-dir DIR]")
+  }
+}
+
 /** forgeqe notify test [channel]: a test card to every notification channel (or one), to check each arrives. */
 async function cmdNotify(args: string[], flags: Flags): Promise<number> {
   if (args[0] !== "test") throw new Error("Usage: forgeqe notify test [channel]")
@@ -535,6 +599,51 @@ async function cmdEval(args: string[], flags: Flags): Promise<number> {
  * from (ForgeQE's, or an edited copy in .forgeqe/prompts), how an edited one differs from ForgeQE's, and how closely each
  * follows ASD-STE100.
  */
+/**
+ * forgeqe prompts eval [prompt] [--case <id>] [--runs <n>]: runs the evaluation cases of the prompts (ForgeQE's, and
+ * the project's in .forgeqe/evals/prompts), with checks decided by code, and compares each pass rate with the last run.
+ */
+async function cmdPromptEval(args: string[], flags: Flags): Promise<number> {
+  const config = loadConfig(configOpts(flags))
+  const runs = Math.max(1, Number(strFlag(flags, "runs")) || 1)
+  const dirs = [BUILTIN_CASES, ...(config.configPath ? [path.join(path.dirname(config.configPath), ".forgeqe", "evals", "prompts")] : [])]
+  const cases = loadPromptCases(dirs, { prompt: args[0], case: strFlag(flags, "case") })
+  if (!cases.length) throw new Error(`No evaluation cases${args[0] ? ` for ${args[0]}` : ""}. They are in ${dirs.join(" and ")}, as <prompt>/<case>.yaml.`)
+  const before = previousRates(config)
+  const results: CaseResult[] = []
+  let failed = 0
+  for (const c of cases) {
+    process.stdout.write(`${c.prompt}/${c.id} … `)
+    const r = await runCase(c, config, process.cwd(), runs)
+    results.push(r)
+    if (r.skipped) {
+      console.log(`skipped (${r.skipped})`)
+      continue
+    }
+    const passed = r.runs.filter((x) => x.pass).length
+    if (passed < r.runs.length) failed++
+    const was = before.get(`${c.prompt}/${c.id}`)
+    const tokens = Math.round(r.runs.reduce((a, x) => a + x.tokens, 0) / r.runs.length / 100) / 10
+    console.log(`${passed === r.runs.length ? "✓" : "✗"} ${passed}/${r.runs.length}${was ? ` (was ${was[0]}/${was[1]})` : ""}  ${tokens}K tokens a run  ${c.title}`)
+    // Each check that failed in any run, once, with what was seen.
+    const seen = new Set<string>()
+    for (const run of r.runs) {
+      if (run.error) console.log(`    error: ${run.error}`)
+      for (const ch of run.checks.filter((x) => !x.pass && !seen.has(x.id))) {
+        seen.add(ch.id)
+        console.log(`    ✗ ${ch.id}: ${ch.detail}`)
+      }
+    }
+    const seenText = r.runs.find((x) => x.seen)?.seen
+    if (seenText) console.log(`    output: ${seenText}`)
+  }
+  const file = saveResults(config, results)
+  const ran = results.filter((r) => !r.skipped)
+  const runsAll = ran.flatMap((r) => r.runs)
+  console.log(`\n${runsAll.filter((x) => x.pass).length} of ${runsAll.length} runs passed in ${ran.length} cases${results.length > ran.length ? `; ${results.length - ran.length} skipped` : ""}. Results: ${path.relative(process.cwd(), file) || file}`)
+  return failed ? 1 : 0
+}
+
 function cmdPrompts(args: string[], flags: Flags): number {
   loadConfig(configOpts(flags))
   const action = args[0] || "list"
@@ -547,20 +656,30 @@ function cmdPrompts(args: string[], flags: Flags): number {
     return 0
   }
   if (action === "check") {
-    // ASD-STE100: each prompt in use (ForgeQE's or the edited copy) scored, and with a name, the sentences to fix.
+    // The prompting standard (src/promptstyle.ts) for each prompt in use, ForgeQE's or the edited copy; with a name,
+    // every issue to fix.
     const all = listPrompts().filter((p) => !name || p.name === name)
     if (name && !all.length) throw new Error(`No prompt named "${name}". forgeqe prompts lists them.`)
     const width = Math.max(...all.map((p) => p.name.length))
-    let below = 0
+    let failing = 0
     for (const p of all) {
       const text = readFileSync(p.file, "utf8").replace(/^---\n[\s\S]*?\n---\n/, "")
-      const s = steScore(text)
-      if (s.score < STE_TARGET) below++
-      console.log(`${s.score >= STE_TARGET ? "✓" : "✗"} ${p.name.padEnd(width)}  ${String(Math.round(s.score * 100)).padStart(3)}%  ${s.compliant} of ${s.sentences} sentences${p.source === "built-in" ? "" : `  (${p.source})`}`)
-      if (name) for (const i of s.issues) console.log(`  - ${i.issues.map((x) => x.detail).join("; ")}\n    ${i.text}`)
+      const kind = promptKind(p.kind)
+      const r = kind ? checkStyle(text, kind) : undefined
+      const issues = r ? r.issues : [{ rule: "kind", detail: `no kind in the header; use one of ${PROMPT_KINDS.join(", ")}` }]
+      if (issues.length) failing++
+      const pct = (n: number) => `${String(Math.round(n * 100)).padStart(3)}%`
+      const facts = r && r.kind !== "user" ? `STE ${pct(r.ste)}  RFC 2119 ${r.ruleLines ? pct(r.rfc) : "  –"}${r.kind === "structured" ? `  examples ${r.examples}` : ""}` : ""
+      console.log(`${issues.length ? "✗" : "✓"} ${p.name.padEnd(width)}  ${(kind || "?").padEnd(10)} ${facts}${issues.length ? `  ${issues.length} issue${issues.length === 1 ? "" : "s"}` : ""}${p.source === "built-in" ? "" : `  (${p.source})`}`)
+      if (name) {
+        for (const i of issues) console.log(`  - ${i.rule}: ${i.detail}`)
+        for (const i of steScore(text).issues) console.log(`  - ste: ${i.issues.map((x) => x.detail).join("; ")}\n    ${i.text}`)
+      }
     }
-    console.log(`\nASD-STE100 writing rules: 20 words or fewer in an instruction, 25 in a description, one instruction per sentence, the active voice in instructions, and approved words. Target: ${Math.round(STE_TARGET * 100)}% of sentences.${name ? "" : " forgeqe prompts check <name> lists the sentences to fix."}`)
-    return below ? 1 : 0
+    console.log(
+      `\nThe standard: ASD-STE100 (${Math.round(STE_TARGET * 100)}% of sentences), RFC 2119 key words for rules (${Math.round(RFC_TARGET * 100)}% of rule lines, no lower-case must/should), the sections of each kind, worked examples for structured prompts, and an execution contract for agents.${name ? "" : " forgeqe prompts check <name> lists what to fix."}`,
+    )
+    return failing ? 1 : 0
   }
   if (!name) throw new Error(`Usage: forgeqe prompts ${action} <name>  (forgeqe prompts lists the names)`)
   const where = promptFile(name)
@@ -809,6 +928,7 @@ async function runAgent(cfg: AppConfig, flags: Flags, text: string, maxSteps: nu
       signal: controller.signal,
       context: () => ({
         headed: boolFlag(flags, "headed"),
+        browserProvider: browserProviderFlag(flags),
         maxSteps,
         url: strFlag(flags, "url"),
         ...memoryFlags(flags),
@@ -869,7 +989,17 @@ async function cmdMcp(args: string[], flags: Flags): Promise<number> {
   const repo = repoFlag(flags)
   const cwd = repo || process.cwd()
   const log = toolPrinter(false, (line) => process.stderr.write(`${line}\n`), detailOf(flags))
-  const context = (): ToolContext => ({ config: cfg, cwd, headed: boolFlag(flags, "headed"), maxSteps: maxStepsFlag(flags), url: strFlag(flags, "url"), ...memoryFlags(flags), emit: log, session: "server" })
+  const context = (): ToolContext => ({
+    config: cfg,
+    cwd,
+    headed: boolFlag(flags, "headed"),
+    browserProvider: browserProviderFlag(flags),
+    maxSteps: maxStepsFlag(flags),
+    url: strFlag(flags, "url"),
+    ...memoryFlags(flags),
+    emit: log,
+    session: "server",
+  })
   const server = createMcpServer({ tools: TOOLS, context, instructions: () => environmentNotes(context()), version: packageVersion() })
   process.stderr.write(`ForgeQE MCP server on stdio (${TOOLS.length} tools, working in ${cwd})\n`)
   await serveStdio(server)
@@ -884,6 +1014,7 @@ async function runGoal(cfg: AppConfig, flags: Flags, goal: string, maxSteps: num
   const { result, files } = await executeRun({
     config: cfg,
     goal,
+    browserProvider: browserProviderFlag(flags),
     url: strFlag(flags, "url"),
     headed: boolFlag(flags, "headed"),
     maxSteps,
@@ -1025,6 +1156,7 @@ async function cmdHeal(args: string[], flags: Flags): Promise<number> {
       repo,
       command,
       outDir: strFlag(flags, "out"),
+      browserProvider: browserProviderFlag(flags),
       headed: boolFlag(flags, "headed"),
       maxSteps: maxStepsFlag(flags),
       url: strFlag(flags, "url"),
@@ -1096,6 +1228,7 @@ async function cmdMonitor(refs: string[], flags: Flags): Promise<number> {
       config: cfg,
       checks,
       once,
+      browserProvider: browserProviderFlag(flags),
       headed: boolFlag(flags, "headed"),
       url: strFlag(flags, "url"),
       skills: skillFlags(flags),
@@ -1134,6 +1267,7 @@ async function cmdSuite(refs: string[], flags: Flags): Promise<number> {
       config: cfg,
       cases,
       repo,
+      browserProvider: browserProviderFlag(flags),
       parallel,
       outDir: strFlag(flags, "out"),
       writeBack: boolFlag(flags, "no-write-back") ? false : undefined,