@capagents/forgeqe 1.1.1 → 1.1.2

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

@@ -34,6 +34,10 @@ Usage:
   forgeqe mcp [--repo DIR] [--profile name] [--url URL] [--headed]
                                                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
@@ -67,8 +71,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
@@ -127,6 +131,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

@@ -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,9 +54,10 @@ 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"))
@@ -184,8 +187,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":
@@ -461,6 +466,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 +584,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 +641,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)

package/src/config.ts

@@ -16,7 +16,28 @@ import { currencyCode, currencyForLocale } from "./money.ts"
 import { listPrice, pricesDate, type DeploymentType, type ListPrice } from "./prices.ts"
 import { ragConfig, type RagConfig } from "./cases/rag.ts"
 
+export type BrowserProvider = "local" | "browserstack" | "testmu"
+export type RemoteBrowserProvider = Exclude<BrowserProvider, "local">
+
+export type BrowserRemoteConfig = {
+  provider: RemoteBrowserProvider
+  usernameEnv: string
+  accessKeyEnv: string
+  endpoint: string
+  browser: string
+  browserVersion: string
+  os?: string
+  osVersion?: string
+  platform?: string
+  project?: string
+  build?: string
+  name?: string
+  local: boolean
+  extra?: Record<string, unknown>
+}
+
 export type BrowserConfig = {
+  provider: BrowserProvider
   headless: boolean
   width: number
   height: number
@@ -25,6 +46,7 @@ export type BrowserConfig = {
   visionDetail: "low" | "high"
   allowedHosts: string[]
   startUrl?: string
+  remote?: BrowserRemoteConfig
   /** ForgeQE overlay in a visible browser: edge glow, a bar with the current step, the person's input locked. */
   overlay: boolean
   /** A second model call checks the finished run against the goal, and its verdict can fail a run the agent completed. */
@@ -176,6 +198,34 @@ export type ApiConfig = {
   timeoutSeconds: number
 }
 
+export type BiDatasetConfig =
+  | {
+      id: string
+      title: string
+      kind: "ado_wiql"
+      wiql: string
+      project?: string
+    }
+  | {
+      id: string
+      title: string
+      kind: "jira_jql"
+      jql: string
+    }
+
+export type BiConfig = {
+  /** Title of the generated Evidence project and its landing page. */
+  title: string
+  /** Evidence project root, generated and managed by ForgeQE. */
+  evidenceDir: string
+  /** Exported CSV datasets the Evidence project reads. */
+  dataDir: string
+  /** Static HTML output from `forgeqe bi build`. */
+  buildDir: string
+  /** Declarative external datasets to fetch on each sync/build. */
+  datasets: BiDatasetConfig[]
+}
+
 export type SuiteConfig = {
   /** Browser runs at the same time. Coding runs one at a time. */
   parallel: number
@@ -312,6 +362,8 @@ export type AppConfig = {
   release?: ReleaseThresholds
   /** API and contract tests (api: in forgeqe.yaml): see src/api/. */
   api?: ApiConfig
+  /** Offline BI export and the Evidence project that renders it (bi: in forgeqe.yaml). */
+  bi?: BiConfig
   /** Accessibility standard and accessibility/performance budgets (quality: in forgeqe.yaml): see src/quality/. */
   quality?: QualityConfig
   /** The product's industry and the regulations in scope (domain: in forgeqe.yaml): see src/domain.ts. */
@@ -371,6 +423,68 @@ function visionDetail(raw: unknown): BrowserConfig["visionDetail"] {
   return String(raw || "low").toLowerCase() === "high" ? "high" : "low"
 }
 
+export function browserProvider(raw: unknown): BrowserProvider {
+  const provider = String(raw || "local").trim().toLowerCase().replace(/[\s-]/g, "_")
+  if (!provider || provider === "local") return "local"
+  if (provider === "browserstack") return "browserstack"
+  if (provider === "testmu" || provider === "lambdatest" || provider === "lambda_test") return "testmu"
+  throw new Error(`browser.provider must be local, browserstack, or testmu; got "${String(raw)}".`)
+}
+
+const REMOTE_BROWSER_DEFAULTS: Record<RemoteBrowserProvider, Pick<BrowserRemoteConfig, "usernameEnv" | "accessKeyEnv" | "endpoint">> = {
+  browserstack: {
+    usernameEnv: "BROWSERSTACK_USERNAME",
+    accessKeyEnv: "BROWSERSTACK_ACCESS_KEY",
+    endpoint: "wss://cdp.browserstack.com/playwright",
+  },
+  testmu: {
+    usernameEnv: "LT_USERNAME",
+    accessKeyEnv: "LT_ACCESS_KEY",
+    endpoint: "wss://cdp.lambdatest.com/playwright",
+  },
+}
+
+function objectMap(raw: unknown, where: string): Record<string, unknown> | undefined {
+  if (raw === undefined || raw === null) return undefined
+  if (typeof raw !== "object" || Array.isArray(raw)) throw new Error(`${where} must be a map of names to values.`)
+  return { ...(raw as Record<string, unknown>) }
+}
+
+function browserRemoteConfig(raw: Record<string, unknown>, provider: BrowserProvider): BrowserRemoteConfig | undefined {
+  if (provider === "local") return undefined
+  const remote = asRecord(raw.remote)
+  const defaults = REMOTE_BROWSER_DEFAULTS[provider]
+  const browser = String(remote.browser || "").trim()
+  if (!browser) throw new Error(`browser.remote.browser is required when browser.provider is ${provider}.`)
+  const browserVersion = String(remote.browser_version || remote.browserVersion || "latest").trim() || "latest"
+  const os = String(remote.os || "").trim() || undefined
+  const osVersion = String(remote.os_version || remote.osVersion || "").trim() || undefined
+  const platform = String(remote.platform || "").trim() || undefined
+  if (provider === "browserstack" && (!os || !osVersion)) {
+    throw new Error("browser.remote.os and browser.remote.os_version are required when browser.provider is browserstack.")
+  }
+  if (provider === "testmu" && !platform && !os) {
+    throw new Error("browser.remote.platform is required when browser.provider is testmu, or set browser.remote.os (and optionally os_version).")
+  }
+  const extra = objectMap(remote.extra ?? remote.capabilities, "browser.remote.extra")
+  return {
+    provider,
+    usernameEnv: String(remote.username_env || remote.usernameEnv || defaults.usernameEnv),
+    accessKeyEnv: String(remote.access_key_env || remote.accessKeyEnv || defaults.accessKeyEnv),
+    endpoint: String(remote.endpoint || defaults.endpoint).trim().replace(/\/+$/, ""),
+    browser,
+    browserVersion,
+    ...(os ? { os } : {}),
+    ...(osVersion ? { osVersion } : {}),
+    ...(platform ? { platform } : {}),
+    ...(remote.project ? { project: String(remote.project).trim() } : {}),
+    ...(remote.build ? { build: String(remote.build).trim() } : {}),
+    ...(remote.name ? { name: String(remote.name).trim() } : {}),
+    local: remote.local === true || remote.local_testing === true,
+    ...(extra && Object.keys(extra).length ? { extra } : {}),
+  }
+}
+
 function profileFromRaw(name: string, raw: Record<string, unknown>): LlmProfile {
   const provider = String(raw.provider || "openai") as LlmProfile["provider"]
   return {
@@ -549,6 +663,7 @@ export function loadConfig(opts?: { configPath?: string; profile?: string }): Ap
     profiles,
     llm: profiles[activeProfile] || { ...NO_PROFILE },
     browser: {
+      provider: browserProvider(browser.provider),
       headless: browser.headless !== false,
       width: Number(viewport.width || 1280),
       height: Number(viewport.height || 800),
@@ -557,6 +672,7 @@ export function loadConfig(opts?: { configPath?: string; profile?: string }): Ap
       visionDetail: visionDetail(browser.vision_detail),
       allowedHosts: hosts,
       startUrl: browser.start_url ? String(browser.start_url) : undefined,
+      remote: browserRemoteConfig(browser, browserProvider(browser.provider)),
       overlay: browser.overlay !== false,
       judge: browser.judge === true,
     },
@@ -600,6 +716,7 @@ export function loadConfig(opts?: { configPath?: string; profile?: string }): Ap
     flaky: flakyConfig(asRecord(yaml.flaky)),
     release: releaseThresholds(yaml.release),
     api: apiConfig(asRecord(yaml.api)),
+    bi: biConfig(asRecord(yaml.bi), base, outDir, configPath),
     quality: withBaselineDir(qualityConfig(yaml.quality), base, configPath),
     domain: domainConfig(yaml.domain),
     notify: notifyConfig(yaml.notify),
@@ -836,6 +953,38 @@ function apiConfig(a: Record<string, unknown>): ApiConfig {
   }
 }
 
+function biConfig(b: Record<string, unknown>, base: string, outDir: string, configPath: string | undefined): BiConfig {
+  const evidenceDir = path.resolve(base, String(b.evidence_dir || path.join(".", "evidence")))
+  const defaultDataDir = path.join(evidenceDir, "sources", "forgeqe", "data")
+  const title = String(b.title || "ForgeQE BI").trim() || "ForgeQE BI"
+  const datasets = Object.entries(asRecord(b.datasets)).map(([id, value]) => biDataset(id, asRecord(value)))
+  return {
+    title,
+    evidenceDir,
+    dataDir: path.resolve(base, String(b.data_dir || defaultDataDir)),
+    buildDir: path.resolve(base, String(b.build_dir || path.join(outDir, "bi"))),
+    datasets,
+  }
+}
+
+function biDataset(id: string, raw: Record<string, unknown>): BiDatasetConfig {
+  if (!/^[A-Za-z0-9_-]+$/.test(id)) throw new Error(`bi.datasets.${id}: ids may only use letters, digits, - and _.`)
+  const title = String(raw.title || id.replace(/[-_]+/g, " ").trim()).trim()
+  const kind = String(raw.kind || "").trim().toLowerCase()
+  if (kind === "ado_wiql") {
+    const wiql = String(raw.wiql || "").trim()
+    if (!wiql) throw new Error(`bi.datasets.${id}.wiql is required for kind ado_wiql.`)
+    const project = String(raw.project || "").trim()
+    return { id, title: title || id, kind, wiql, ...(project ? { project } : {}) }
+  }
+  if (kind === "jira_jql") {
+    const jql = String(raw.jql || "").trim()
+    if (!jql) throw new Error(`bi.datasets.${id}.jql is required for kind jira_jql.`)
+    return { id, title: title || id, kind, jql }
+  }
+  throw new Error(`bi.datasets.${id}.kind must be ado_wiql or jira_jql; got "${String(raw.kind || "")}".`)
+}
+
 function optional<K extends string, V>(key: K, value: V | undefined): Partial<Record<K, V>> {
   return value === undefined ? {} : ({ [key]: value } as Record<K, V>)
 }

package/src/engine/bridge.ts

@@ -3,9 +3,9 @@ import { createInterface } from "node:readline"
 
 import type { LlmProfile } from "../llm.ts"
 import type { AgentEvent, CaseReport, MemoryInfo, ReplayMode, RunResult } from "../types.ts"
-import { loginEnvNames } from "../childEnv.ts"
+import { browserProviderEnvNames, loginEnvNames } from "../childEnv.ts"
 import { recordUsage } from "../usage.ts"
-import type { LoginConfig } from "../config.ts"
+import type { BrowserProvider, BrowserRemoteConfig, LoginConfig } from "../config.ts"
 import { debugLogging, logEvent } from "../sessionLog.ts"
 import { engineEnv } from "./setup.ts"
 import { AZURE_IDENTITY_ENV, entraPayload } from "../entra.ts"
@@ -18,6 +18,7 @@ export type EngineRequest = {
   headed: boolean
   maxSteps: number
   allowedHosts: string[]
+  browser?: { provider: BrowserProvider; remote?: BrowserRemoteConfig }
   extendSystemMessage?: string
   /** Page memory folder and replay mode; omit to run without memory. */
   memory?: { dir: string; replay: ReplayMode }
@@ -148,6 +149,33 @@ function llmPayload(p: LlmProfile): Record<string, unknown> {
   return out
 }
 
+function browserPayload(browser: EngineRequest["browser"]): Record<string, unknown> | null {
+  if (!browser) return null
+  return {
+    provider: browser.provider,
+    ...(browser.remote
+      ? {
+          remote: {
+            provider: browser.remote.provider,
+            username_env: browser.remote.usernameEnv,
+            access_key_env: browser.remote.accessKeyEnv,
+            endpoint: browser.remote.endpoint,
+            browser: browser.remote.browser,
+            browser_version: browser.remote.browserVersion,
+            ...(browser.remote.os ? { os: browser.remote.os } : {}),
+            ...(browser.remote.osVersion ? { os_version: browser.remote.osVersion } : {}),
+            ...(browser.remote.platform ? { platform: browser.remote.platform } : {}),
+            ...(browser.remote.project ? { project: browser.remote.project } : {}),
+            ...(browser.remote.build ? { build: browser.remote.build } : {}),
+            ...(browser.remote.name ? { name: browser.remote.name } : {}),
+            local: browser.remote.local,
+            ...(browser.remote.extra ? { extra: browser.remote.extra } : {}),
+          },
+        }
+      : {}),
+  }
+}
+
 export function toRunResult(goal: string, startUrl: string, r: EngineResult): RunResult {
   // The agent's evidence wins over its verdict: a check that does not hold, or a failed case step, fails the run even
   // when the agent called done with success (engines before this rule did not apply it themselves).
@@ -198,6 +226,7 @@ export async function runEngine(opts: {
   const child = spawn(bin!, args, {
     env: engineEnv(debugLogging() ? { ...req.env, BROWSER_USE_LOGGING_LEVEL: "debug" } : req.env, [
       ...(req.llm.auth === "entra" ? AZURE_IDENTITY_ENV : req.llm.apiKeyEnv ? [req.llm.apiKeyEnv] : []),
+      ...browserProviderEnvNames(req.browser || { provider: "local" }),
       ...loginEnvNames(req.logins || []),
     ]),
     stdio: ["pipe", "pipe", "pipe"],
@@ -222,6 +251,7 @@ export async function runEngine(opts: {
     headed: req.headed,
     max_steps: req.maxSteps,
     allowed_hosts: req.allowedHosts,
+    browser: browserPayload(req.browser),
     extend_system_message: req.extendSystemMessage || null,
     memory: req.memory || null,
     logins: loginPayload(req.logins),