agent-ultramode 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 maverick-tr (https://github.com/maverick-tr)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,194 @@
+# ultra
+
+Took the [LLM-as-a-Verifier](https://github.com/llm-as-a-verifier/llm-as-a-verifier) paper (Kwok et al., 2026) and turned it into a simple `/ultra` command for coding agents.
+
+Instead of shipping the agent's first attempt, `ultra` runs your task **N times in isolated git worktrees**, in parallel, then uses the **same model** as a verifier to pick the best result. When it is confident (or when most attempts succeeded) it applies the winning diff to your working tree; when the attempts diverge and it is not sure, it hands you the top candidates. No cross-model dependency, no extra services, no first-attempt lottery.
+
+And unlike most "add a verifier" posts, I benchmarked it before believing it. The receipts are below, good and bad.
+
+## Demo
+
+<video src="https://github.com/maverick-tr/agent-ultramode/raw/main/ultramode.mp4" controls muted playsinline width="100%"></video>
+
+> For a reliable inline player on GitHub, edit this README on github.com and drag `ultramode.mp4` into the editor; GitHub inserts a `https://github.com/.../assets/...` URL that plays inline. The file is committed at [`ultramode.mp4`](./ultramode.mp4).
+
+## The receipts
+
+Benchmarked on **Terminal-Bench** with **DeepSeek V4 Flash 0731** as both the agent and the verifier, running inside **opencode** (N=5 attempts, same-model verifier). Verified end to end with both **OpenCode** and **Claude Code** as the agent (the numbers above are the OpenCode run; a Claude Code number will be added once benchmarked). Works with any agent, not just opencode.
+
+| Slice | base@1 (single shot) | ultra (best-of-N + verify) | oracle@5 (ceiling) |
+|---|:---:|:---:|:---:|
+| All 15 tasks | 24% | **33%** | 40% |
+| 4 recoverable tasks | 40% | **75%** | rescued 3 of 4 |
+
+Overall the verifier captured about **56% of the pass@1 to pass@5 headroom**. On the tasks with real variance, where best-of-N can actually help, it took the passing attempt on `chess-best-move`, `new-encrypt-command`, and `decommissioning-service` (missing only `jupyter-notebook-server`). A 40 to 75 jump on recoverable tasks is not a rounding error.
+
+## How the competition works
+
+```text
+                          your task
+                              |
+      +----------+-----------+-----------+----------+        N attempts, in parallel,
+      |          |           |           |          |        each in its own git worktree
+  worktree1  worktree2   worktree3   worktree4     ...       + a lean sandbox (no MCP,
+      |          |           |           |          |          no plugins, isolated state)
+    agent      agent       agent       agent      agent
+      |          |           |           |          |
+    diff1      diff2       diff3       diff4      diffN
+      +----------+-----------+-----------+----------+
+                              |
+                              v
+        Probabilistic Pivot Tournament   (same model, acting as verifier)
+          1. ring pass    each diff judged once vs a neighbour  -> seed pivots
+          2. pivot duels  field vs the top pivots, K reasoned votes per duel
+          3. score        normalised win-rate; confidence = top1 minus top2
+                              |
+                              v
+                           decide
+          confident, or most attempts changed something  ->  APPLY the winner
+          diverged and not confident                     ->  show top candidates
+```
+
+1. **Fan out.** N detached git worktrees off `HEAD`; the agent runs the full task in each, in parallel, isolated so the attempts never collide.
+2. **Run each attempt lean.** Every attempt is a full agent process, but stripped to essentials (no MCP servers, no other plugins, its own private state). That is what makes N real agents in parallel take seconds instead of minutes.
+3. **Verify.** The tournament ranks the N diffs by same-model reasoned votes. Confidence is the win-rate margin between the top two.
+4. **Decide.** Confident or a clear majority produced a change: apply the winner to your working tree (uncommitted, you review before committing). Otherwise: present the top candidates instead of guessing.
+
+Progress streams live: phase titles in the web UI tool card, and toasts in the terminal.
+
+## Install
+
+```sh
+opencode plugin agent-ultramode
+```
+
+That is the whole setup. With no options it drafts and verifies with your **current session model**, so `/ultra <task>` just works:
+
+```text
+/ultra fix the failing test in foo/bar
+```
+
+`ultra` branches attempts off `HEAD`, so run it inside a git repo with at least one commit.
+
+**Pin a specific model (optional).** To draft and verify with a model other than the session one:
+
+```jsonc
+{ "plugin": [ ["agent-ultramode", { "model": "myprovider/my-model" }] ] }
+```
+
+**Run a different agent (Claude Code, Grok, Pi, Codex, ...).** The `agent` option is the command run once per attempt, with `{task}` substituted and the cwd set to an isolated worktree. Point it at any CLI that edits files and exits:
+
+```jsonc
+["agent-ultramode", { "agent": "claude -p --dangerously-skip-permissions \"{task}\"" }]  // Claude Code (verified)
+["agent-ultramode", { "agent": "pi \"{task}\"" }]                                        // pi
+["agent-ultramode", { "agent": "grok build \"{task}\"" }]                                // grok
+```
+
+Adjust each agent's flags for headless, file-editing runs (for example Claude Code's permission mode). The best-of-N and verify loop stays the same, which makes ultra-mode easy to push onto any agent you use.
+
+## Configure
+
+Every option also reads from an `ULTRA_*` env var.
+
+| Option | Default | Meaning |
+|---|---|---|
+| `model` | your current session model | `"provider/model-id"` used to run attempts and to verify |
+| `agent` | run the current model | the command run once per attempt; `{task}` substituted, cwd is an isolated worktree |
+| `n` | `4` | number of attempts (2 to 8) |
+| `k` | `3` | reasoned votes per verifier duel |
+| `conf` | `0.34` | confidence margin at or above which the winner is applied |
+| `baseURL` / `apiKey` | from the provider | override the OpenAI-compatible endpoint / key for the verifier |
+| `effort` | `"none"` | `reasoning_effort` for the verifier calls (kept low so judging stays fast) |
+| `concurrency` | `6` | how many attempts run at once |
+| `agentTimeout` | `600000` | per-attempt timeout in ms |
+
+## Use without opencode (the CLI)
+
+Same loop, no opencode host required. Install and run it in any git repo:
+
+```sh
+npm i -g agent-ultramode        # or: npx agent-ultramode "<task>"
+```
+
+```sh
+agent-ultramode "fix the failing test in foo/bar"
+```
+
+By default each attempt runs `opencode run` (and it tells you clearly if opencode is not installed). Point `--agent` at anything else that edits files:
+
+```sh
+agent-ultramode -t "add rate limiting to /login" \
+  --agent 'claude -p --dangerously-skip-permissions "{task}"' \
+  --verify-model gpt-4o-mini
+```
+
+**Multiple models in one pass.** Pass `--agent` more than once to spread the attempts across different models, judged by one neutral verifier:
+
+```sh
+agent-ultramode -t "design and implement the data migration" \
+  --agent 'claude -p --dangerously-skip-permissions "{task}"' \
+  --agent 'opencode run --model grok "{task}"' \
+  --agent 'opencode run --model deepseek-v4-flash "{task}"' \
+  --n 6 --verify-model gpt-4o-mini
+```
+
+The 6 attempts round-robin across the three agents, and the verifier picks the best regardless of which model produced it. Good for one hard task where you want several strong models to take a shot.
+
+The verifier needs an OpenAI-compatible endpoint: by default it reads `OPENAI_API_KEY` and `OPENAI_BASE_URL`, or pass `--api-key` / `--base-url` / `--verify-model`. Run `agent-ultramode --help` for all options.
+
+## Why I built this, and the honest story
+
+I wanted to know if best-of-N verification could squeeze real quality out of a cheap-but-capable model without reaching for a bigger, pricier one. So, ran it on real Terminal-Bench tasks and let the numbers decide. What I found:
+
+- **Planning-first best-of-N does nothing for execution tasks.** Drafting N plans, picking the best, then executing once: **0 out of 5** outcomes changed on Terminal-Bench, at 3 to 10 times the cost. It amplifies effort, not capability. I dropped it.
+- **Best-of-N over full trajectories plus a same-model verifier does work.** This is the version that ships.
+- **A fancier verifier did not help.** A multi-criteria checklist tied the plain holistic judge and sometimes did worse. Same-model verification hits a ceiling that more prompting does not break.
+- **Confidence is a real signal, but a noisy one.** Useful, not a magic gate.
+
+It significantly helps on the tasks that matter, and I can point at the per-task data.
+
+## The honest caveats (because benchmarks lie by omission)
+
+1. **Confidence is a noisy signal at this scale.** The one miss (`jupyter`) had confidence 0.25, higher than two tasks it got right (0.17, 0.21). Some beyond-capability tasks even show high confidence while being pure failures. "Trust when confident" is directionally real, not a clean gate.
+2. **It cannot help beyond-capability tasks.** 9 of the 15 never passed in 5 tries, and no verifier manufactures a solution that was never there.
+3. **n=15 (4 with real variance) is a credible but modest sample.** Enough to headline honestly, not enough to over-claim precision.
+
+## What this likely means at scale
+
+The 15 tasks were deliberately failure-skewed, so the +9 points is not what you would see on the whole benchmark. On the full set the model already passes about 83%, so most tasks have no headroom. My honest estimate for a full run is a **modest +2 to +5 points on average**, because the dramatic gains only land on the minority of tasks the model *sometimes* solves. Average lift small, per-recoverable-task lift large. Same fact, two views.
+
+## Roadmap
+
+- [x] **Standalone CLI** (`npx agent-ultramode`) so the loop runs anywhere, with any agent, no opencode required.
+- [x] **Multiple models in one pass** (repeatable `--agent`): spread attempts across different models, one neutral verifier picks the best.
+- [x] **OpenCode and Claude Code** verified end to end.
+- [ ] **First-class agent integrations** with tuned defaults, and a benchmark number, for Claude Code, Grok, Pi, and Codex.
+- [ ] Native slash-command or MCP packaging per agent. Contributions welcome.
+
+## Credits
+
+The verification method is the **Probabilistic Pivot Tournament** from **LLM-as-a-Verifier** (Kwok et al., 2026), reimplemented from the paper. The `K`-sample reward estimate and the apply policy are our adaptations. The self-verification ceiling we ran into is documented in the cross-model and weak-verifier literature, worth reading before you assume same-model verification is a free lunch:
+
+- Paper: [arXiv:2607.05391](https://arxiv.org/abs/2607.05391)
+- Repo: [llm-as-a-verifier/llm-as-a-verifier](https://github.com/llm-as-a-verifier/llm-as-a-verifier)
+- On the ceiling: [LLM-as-a-Jury (cross-model)](https://arxiv.org/html/2607.10139), [Weaver: weak verifiers](https://arxiv.org/html/2506.18203), [Generative Verifiers](https://arxiv.org/pdf/2408.15240)
+
+```bibtex
+@misc{kwok2026llmasaverifiergeneralpurposeverificationframework,
+      title={LLM-as-a-Verifier: A General-Purpose Verification Framework},
+      author={Jacky Kwok and Shulu Li and Pranav Atreya and Yuejiang Liu and
+              Yixing Jiang and Chelsea Finn and Marco Pavone and Ion Stoica
+              and Azalia Mirhoseini},
+      year={2026},
+      eprint={2607.05391},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2607.05391}
+}
+```
+
+Built for [opencode](https://opencode.ai). Zero heavy dependencies: opencode's bundled `@opencode-ai/plugin`, the global `fetch`, and an OpenAI-compatible endpoint.
+
+## License and author
+
+MIT, by [maverick-tr](https://github.com/maverick-tr). Built on the method from [llm-as-a-verifier](https://github.com/llm-as-a-verifier/llm-as-a-verifier) (Kwok et al., 2026). See [LICENSE](./LICENSE).

package/cli.mjs

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+// agent-ultramode: best-of-N for coding agents with a same-model verifier, as a CLI.
+//
+// Runs your task N times in isolated git worktrees, verifies the diffs with a
+// Probabilistic Pivot Tournament (the same-model verifier from llm-as-a-verifier),
+// and applies the winner. No opencode host required. Defaults the per-attempt
+// agent to `opencode run`, but `--agent` takes any CLI that edits files.
+//
+// Node 18+ (uses global fetch and node:util parseArgs). Zero dependencies.
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { parseArgs } from "node:util"
+
+const execFileP = promisify(execFile)
+const int = (v, def, lo, hi) => { const n = parseInt(String(v ?? ""), 10); return Number.isFinite(n) ? Math.max(lo, Math.min(hi, n)) : def }
+const err = (m) => process.stderr.write(m + "\n")
+
+function printHelp() {
+  err(`agent-ultramode - best-of-N for coding agents with a same-model verifier
+
+USAGE
+  agent-ultramode --task "<what to do>" [options]
+  agent-ultramode "<what to do>" [options]
+
+OPTIONS
+  -t, --task <text>        the task to solve (or pass it as positional words)
+  -a, --agent <cmd>        command run per attempt; "{task}" substituted, cwd is an isolated
+                           worktree. Repeatable: pass several to spread attempts across
+                           different models in one pass (round-robin). default: opencode run "{task}"
+  -n, --n <int>            number of attempts, 2 to 8 (default 4)
+      --k <int>            reasoned votes per verifier duel (default 3)
+      --conf <float>       confidence margin to auto-apply (default 0.34)
+  -m, --verify-model <id>  model id for the verifier (default $ULTRA_VERIFY_MODEL or gpt-4o-mini)
+      --base-url <url>     verifier OpenAI-compatible endpoint (default $OPENAI_BASE_URL or OpenAI)
+      --api-key <key>      verifier api key (default $OPENAI_API_KEY)
+      --repo <path>        repo to run in (default: current directory)
+      --concurrency <int>  attempts to run at once (default 6)
+      --effort <level>     verifier reasoning_effort (default none)
+  -h, --help               show this help
+
+EXAMPLES
+  # default: opencode as the per-attempt agent, verify with your OpenAI key
+  agent-ultramode "fix the failing test in foo/bar"
+
+  # use Claude Code as the agent
+  agent-ultramode -t "add rate limiting to /login" \\
+    --agent 'claude -p --dangerously-skip-permissions "{task}"' \\
+    --verify-model gpt-4o-mini
+
+  # point the verifier at any OpenAI-compatible endpoint
+  agent-ultramode "..." --base-url http://localhost:8000/v1 --api-key x --verify-model my-model
+`)
+}
+
+async function git(cwd, ...args) {
+  const { stdout } = await execFileP("git", args, { cwd, maxBuffer: 32 * 1024 * 1024 })
+  return stdout
+}
+
+function pLimit(max) {
+  let active = 0
+  const q = []
+  const next = () => { active--; q.shift()?.() }
+  return async (fn) => {
+    if (active >= max) await new Promise((r) => q.push(r))
+    active++
+    try { return await fn() } finally { next() }
+  }
+}
+
+async function chat(C, content) {
+  const body = { model: C.verifyModel, messages: [{ role: "user", content }], max_tokens: 12000, temperature: 0.9 }
+  if (C.effort) body.reasoning_effort = C.effort
+  const res = await fetch(`${C.baseURL.replace(/\/$/, "")}/chat/completions`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${C.apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) throw new Error(`verifier HTTP ${res.status}`)
+  const j = await res.json()
+  const m = j?.choices?.[0]?.message ?? {}
+  return `${m.content ?? ""}\n${m.reasoning_content ?? ""}`
+}
+
+async function judge(C, limit, task, a, b) {
+  const prompt =
+    `A coding task and two candidate solutions (agent log tail + the diff each produced). Decide which ` +
+    `more likely FULLY and correctly accomplishes the task. Be skeptical: prefer concrete evidence of a ` +
+    `correct, complete change with no errors; a diff that looks plausible but is incomplete or wrong should ` +
+    `lose.\n\nTASK:\n${task}\n\n=== A ===\n${a}\n\n=== B ===\n${b}\n\n` +
+    `Reason briefly, then end with exactly one line: 'FINAL: A' or 'FINAL: B'.`
+  try {
+    const out = (await limit(() => chat(C, prompt))).toUpperCase()
+    const ms = out.match(/FINAL:\s*([AB])/g)
+    return ms ? ms[ms.length - 1].slice(-1) : null
+  } catch { return null }
+}
+
+async function tournament(C, task, summaries) {
+  const n = summaries.length
+  const ids = Array.from({ length: n }, (_, i) => i)
+  if (n <= 1) return { ranked: ids, conf: 1 }
+  const limit = pLimit(C.cc)
+  const order = [...ids]
+  for (let i = order.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [order[i], order[j]] = [order[j], order[i]] }
+  const ring = Object.fromEntries(ids.map((i) => [i, 0]))
+  await Promise.all(order.map(async (id, i) => {
+    const b = order[(i + 1) % n]
+    const v = await judge(C, limit, task, summaries[id], summaries[b])
+    ring[v === "B" ? b : id]++
+  }))
+  const pivots = [...ids].sort((x, y) => ring[y] - ring[x]).slice(0, Math.min(2, n))
+  const nonp = ids.filter((i) => !pivots.includes(i))
+  const pairs = []
+  for (const np of nonp) for (const pv of pivots) pairs.push([np, pv])
+  for (let i = 0; i < pivots.length; i++) for (let j = i + 1; j < pivots.length; j++) pairs.push([pivots[i], pivots[j]])
+  const mass = Object.fromEntries(ids.map((i) => [i, 0]))
+  const games = Object.fromEntries(ids.map((i) => [i, 0]))
+  await Promise.all(pairs.map(async ([x, y]) => {
+    const votes = await Promise.all(Array.from({ length: C.k }, () => judge(C, limit, task, summaries[x], summaries[y])))
+    const na = votes.filter((v) => v === "A").length
+    const nb = votes.filter((v) => v === "B").length
+    const px = na + nb === 0 ? 0.5 : na / (na + nb)
+    mass[x] += px; mass[y] += 1 - px; games[x]++; games[y]++
+  }))
+  const ratio = (i) => (games[i] ? mass[i] / games[i] : ring[i] / Math.max(1, n - 1))
+  const ranked = [...ids].sort((a, b) => ratio(b) - ratio(a))
+  return { ranked, conf: ratio(ranked[0]) - ratio(ranked[1]) }
+}
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      task: { type: "string", short: "t" },
+      agent: { type: "string", short: "a", multiple: true },
+      n: { type: "string", short: "n" },
+      k: { type: "string" },
+      conf: { type: "string" },
+      "verify-model": { type: "string", short: "m" },
+      "base-url": { type: "string" },
+      "api-key": { type: "string" },
+      repo: { type: "string" },
+      concurrency: { type: "string" },
+      effort: { type: "string" },
+      help: { type: "boolean", short: "h" },
+    },
+  })
+
+  if (values.help) { printHelp(); process.exit(0) }
+  const task = (values.task || positionals.join(" ")).trim()
+  if (!task) { printHelp(); err("\nagent-ultramode: pass a --task (or task words) to run."); process.exit(1) }
+
+  const agents = values.agent && values.agent.length ? values.agent : ['opencode run "{task}"']
+  const n = int(values.n, 4, 2, 8)
+  const k = int(values.k, 3, 1, 7)
+  const conf = Number(values.conf ?? 0.34)
+  const cc = int(values.concurrency, 6, 1, 12)
+  const agentTimeout = 600000
+  const C = {
+    verifyModel: values["verify-model"] || process.env.ULTRA_VERIFY_MODEL || process.env.OPENAI_MODEL || "gpt-4o-mini",
+    baseURL: values["base-url"] || process.env.OPENAI_BASE_URL || process.env.ULTRA_BASE_URL || "https://api.openai.com/v1",
+    apiKey: values["api-key"] || process.env.OPENAI_API_KEY || process.env.ULTRA_API_KEY || "",
+    effort: values.effort ?? process.env.ULTRA_EFFORT ?? "none",
+    k, cc,
+  }
+
+  // Friendly check: an opencode agent must exist on PATH.
+  const binOf = (a) => a.trim().split(/\s+/)[0]
+  for (const b of [...new Set(agents.map(binOf))]) {
+    if (b !== "opencode") continue
+    try { await execFileP(b, ["--version"], { timeout: 10000 }) }
+    catch {
+      err(`\nagent-ultramode: '${b}' is not installed or not on your PATH.\n` +
+        `Install it, or pass --agent to use a different agent, for example:\n` +
+        `  --agent 'claude -p --dangerously-skip-permissions "{task}"'\n`)
+      process.exit(1)
+    }
+  }
+  if (!C.apiKey) {
+    err(`\nagent-ultramode: no verifier api key. The verifier needs an OpenAI-compatible model to judge attempts.\n` +
+      `Set OPENAI_API_KEY (and OPENAI_BASE_URL / --verify-model for a non-OpenAI endpoint), or pass --api-key.\n`)
+    process.exit(1)
+  }
+
+  const repoArg = values.repo || process.cwd()
+  let repo
+  try { repo = (await git(repoArg, "rev-parse", "--show-toplevel")).trim() } catch { err(`\nagent-ultramode: '${repoArg}' is not inside a git repo.`); process.exit(1) }
+  let base
+  try { base = (await git(repo, "rev-parse", "HEAD")).trim() } catch { err(`\nagent-ultramode: the repo has no commits yet (need a HEAD to branch attempts from).`); process.exit(1) }
+
+  const work = await mkdtemp(join(tmpdir(), "ultramode-"))
+  const worktrees = []
+  try {
+    const label = agents.length > 1 ? `${agents.length} agents (round-robin)` : `'${binOf(agents[0])}'`
+    err(`>>> fan-out: ${n} attempts off ${base.slice(0, 8)} with ${label} ...`)
+    for (let i = 0; i < n; i++) {
+      const wt = join(work, `attempt-${i}`)
+      await git(repo, "worktree", "add", "--detach", wt, base)
+      worktrees.push(wt)
+    }
+    const limit = pLimit(Math.max(1, Math.min(cc, n)))
+    const esc = task.replace(/"/g, '\\"')
+    const outs = await Promise.all(worktrees.map((wt, i) => limit(async () => {
+      const cmd = agents[i % agents.length].replace("{task}", esc)
+      const d = join(work, `xdg-${i}`)
+      await mkdir(d, { recursive: true }).catch(() => {})
+      const env = {
+        ...process.env,
+        XDG_DATA_HOME: d, XDG_STATE_HOME: d, XDG_CACHE_HOME: d,
+        OPENCODE_DISABLE_DEFAULT_PLUGINS: "1", OPENCODE_DISABLE_AUTOUPDATE: "1", OPENCODE_DISABLE_MODELS_FETCH: "1",
+      }
+      let log = ""
+      try {
+        const { stdout, stderr } = await execFileP("bash", ["-lc", `exec </dev/null; ${cmd}`], { cwd: wt, env, timeout: agentTimeout, maxBuffer: 32 * 1024 * 1024 })
+        log = (stdout || "") + (stderr || "")
+      } catch (e) { log = `agent error: ${e?.message || e}` }
+      await git(wt, "add", "-A").catch(() => {})
+      const diff = await git(wt, "diff", "--cached").catch(() => "")
+      err(`    attempt ${i} [${binOf(agents[i % agents.length])}]: ${diff ? diff.length + " diff chars" : "no changes"}`)
+      return { diff, summary: `AGENT LOG (tail):\n${log.slice(-1500)}\n\nDIFF:\n${diff.slice(0, 6000) || "(no changes)"}` }
+    })))
+
+    const diffs = outs.map((o) => o.diff)
+    const summaries = outs.map((o) => o.summary)
+    if (diffs.every((d) => !d.trim())) {
+      console.log("agent-ultramode: none of the attempts made any changes. Try a more specific task, or check that your agent can edit files headlessly.")
+      return
+    }
+
+    err(`>>> verify: probabilistic pivot tournament (${C.verifyModel}) ...`)
+    const { ranked, conf: margin } = await tournament(C, task, summaries)
+    const best = ranked[0]
+    const nonEmpty = diffs.filter((d) => d.trim()).length
+    const majority = nonEmpty >= Math.max(2, Math.ceil(n / 2))
+
+    if ((margin >= conf || majority) && diffs[best].trim()) {
+      const patch = join(work, "winner.patch")
+      await writeFile(patch, diffs[best])
+      const why = margin >= conf ? `confidence ${margin.toFixed(2)}` : `top pick of ${nonEmpty}/${n}, margin ${margin.toFixed(2)}`
+      try {
+        await git(repo, "apply", "--3way", patch)
+        console.log(`\n🏆 applied the best of ${n} attempts (${why}). The change is in your working tree; review it, then commit.`)
+      } catch (e) {
+        console.log(`\nverified the best attempt (${why}) but the patch did not apply cleanly (${e?.message || e}). The diff:\n\n${diffs[best].slice(0, 8000)}`)
+      }
+    } else {
+      console.log(`\nattempts diverged and the verifier was not confident (margin ${margin.toFixed(2)}); applied nothing. Top candidates:\n`)
+      ranked.slice(0, 3).forEach((idx, r) => {
+        console.log(`# ${r + 1}  attempt ${idx}  (${diffs[idx].length} chars)\n${diffs[idx].slice(0, 4000) || "(no changes)"}\n`)
+      })
+    }
+  } finally {
+    for (const wt of worktrees) await git(repo, "worktree", "remove", "--force", wt).catch(() => {})
+    await rm(work, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+main().catch((e) => { err(`agent-ultramode: ${e?.message || e}`); process.exit(1) })

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "agent-ultramode",
+  "version": "0.1.0",
+  "description": "Best-of-N for coding agents with a same-model verifier: run your task N times in isolated git worktrees and apply the verified winner. A /ultra command for opencode.",
+  "module": "ultra.ts",
+  "main": "ultra.ts",
+  "exports": {
+    ".": "./ultra.ts"
+  },
+  "type": "module",
+  "bin": {
+    "agent-ultramode": "cli.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "ultra.ts",
+    "cli.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "plugin",
+    "best-of-n",
+    "verifier",
+    "llm-as-a-verifier",
+    "coding-agent",
+    "ultra"
+  ],
+  "license": "MIT",
+  "author": "maverick-tr (https://github.com/maverick-tr)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maverick-tr/agent-ultramode.git"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.153",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/ultra.ts

@@ -0,0 +1,381 @@
+/**
+ * ultra - best-of-N trajectories + confidence-gated same-model verifier, for opencode.
+ *
+ * `/ultra <task>` runs the task N times in isolated git worktrees, ranks the results
+ * with the same model acting as a verifier (a Probabilistic Pivot Tournament, from
+ * llm-as-a-verifier), then:
+ *   high confidence -> applies the winning diff to your working tree
+ *   low  confidence -> shows you the top candidates and applies nothing
+ * (a low-confidence pick is a coin flip and should not be applied silently).
+ *
+ * This is the version validated on Terminal-Bench: plan-first best-of-N gave no edge,
+ * but best-of-N over full trajectories + this verifier lifted the recoverable tasks
+ * from 40% to 75% (n=15, same model, no cross-model dependency).
+ *
+ * Install (opencode.json):
+ *   { "plugin": [ ["file:///abs/path/ultra.ts", { "model": "provider/model", "n": 5 }] ] }
+ * Then: /ultra fix the failing test in foo/bar
+ *
+ * Zero deps: node built-ins + global fetch + an OpenAI-compatible endpoint.
+ */
+import type { Plugin } from "@opencode-ai/plugin"
+import { tool } from "@opencode-ai/plugin"
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises"
+import { existsSync } from "node:fs"
+import { tmpdir, homedir } from "node:os"
+import { join } from "node:path"
+
+const execFileP = promisify(execFile)
+type Opts = Record<string, any>
+const VERSION = "0821g"
+
+interface Cfg {
+  url: string
+  key: string
+  model: string
+  provider: string
+  effort: string
+  agent: string
+  n: number
+  k: number
+  topk: number
+  conf: number
+  judgeTokens: number
+  cc: number
+  agentTimeoutMs: number
+}
+
+const num = (v: any, def: number, lo: number, hi: number): number => {
+  const n = Number.parseInt(String(v ?? ""), 10)
+  return Number.isFinite(n) ? Math.max(lo, Math.min(hi, n)) : def
+}
+
+function buildCfg(opts: Opts): Cfg {
+  // Endpoint + model default to the CURRENT SESSION model (captured in the chat.params hook
+  // below); plugin options and ULTRA_* env vars override. The per-attempt agent defaults to
+  // opencode's own run command, and any other CLI works via the agent option.
+  const ref = String(opts.model ?? process.env.ULTRA_MODEL ?? "")
+  const s = ref.indexOf("/")
+  const provider = s >= 0 ? ref.slice(0, s) : String(opts.provider ?? process.env.ULTRA_PROVIDER ?? "")
+  return {
+    url: String(opts.baseURL ?? process.env.ULTRA_BASE_URL ?? ""),
+    key: String(opts.apiKey ?? process.env.ULTRA_API_KEY ?? ""),
+    model: s >= 0 ? ref.slice(s + 1) : ref,
+    provider,
+    // "none" keeps the verifier fast and non-truncating.
+    effort: String(opts.effort ?? process.env.ULTRA_EFFORT ?? "none"),
+    // the agent to run in each worktree; {task} is substituted, CWD = the worktree.
+    agent: String(opts.agent ?? process.env.ULTRA_AGENT ?? 'opencode run "{task}"'),
+    n: num(opts.n ?? process.env.ULTRA_N, 4, 2, 8),
+    k: num(opts.k ?? process.env.ULTRA_K, 3, 1, 7),
+    topk: 2,
+    conf: Number(opts.conf ?? process.env.ULTRA_CONF ?? 0.34),
+    judgeTokens: num(opts.judgeTokens ?? process.env.ULTRA_JUDGE_TOKENS, 12000, 500, 200000),
+    cc: num(opts.concurrency ?? process.env.ULTRA_CC, 6, 1, 12),
+    agentTimeoutMs: num(opts.agentTimeout ?? process.env.ULTRA_AGENT_TIMEOUT, 600000, 30000, 1800000),
+  }
+}
+
+function pLimit(max: number) {
+  let active = 0
+  const q: (() => void)[] = []
+  const next = () => { active--; q.shift()?.() }
+  return async <T>(fn: () => Promise<T>): Promise<T> => {
+    if (active >= max) await new Promise<void>((r) => q.push(r))
+    active++
+    try { return await fn() } finally { next() }
+  }
+}
+
+async function git(cwd: string, ...args: string[]): Promise<string> {
+  const { stdout } = await execFileP("git", args, { cwd, maxBuffer: 32 * 1024 * 1024 })
+  return stdout
+}
+
+// one non-streaming verifier call; a failure is swallowed by the caller (null vote).
+async function chat(C: Cfg, content: string): Promise<string> {
+  const body: Record<string, any> = {
+    model: C.model,
+    messages: [{ role: "user", content }],
+    max_tokens: C.judgeTokens,
+    temperature: 0.9,
+  }
+  if (C.effort) body.reasoning_effort = C.effort
+  const res = await fetch(`${C.url.replace(/\/$/, "")}/chat/completions`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${C.key}`, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) throw new Error(`HTTP ${res.status}`)
+  const j: any = await res.json()
+  const m = j?.choices?.[0]?.message ?? {}
+  return `${m.content ?? ""}\n${m.reasoning_content ?? ""}`
+}
+
+async function judge(C: Cfg, limit: ReturnType<typeof pLimit>, task: string, a: string, b: string): Promise<"A" | "B" | null> {
+  const prompt =
+    `A coding task and two candidate solutions (agent log tail + the diff each produced). Decide which ` +
+    `more likely FULLY and correctly accomplishes the task. Be skeptical: prefer concrete evidence of a ` +
+    `correct, complete change with no errors; a diff that looks plausible but is incomplete or wrong should ` +
+    `lose.\n\nTASK:\n${task}\n\n=== A ===\n${a}\n\n=== B ===\n${b}\n\n` +
+    `Reason briefly, then end with exactly one line: 'FINAL: A' or 'FINAL: B'.`
+  try {
+    const out = (await limit(() => chat(C, prompt))).toUpperCase()
+    const ms = out.match(/FINAL:\s*([AB])/g)
+    return ms ? (ms[ms.length - 1].slice(-1) as "A" | "B") : null
+  } catch {
+    return null
+  }
+}
+
+// Probabilistic Pivot Tournament -> ranked indices + confidence (top1-top2 win-ratio margin).
+async function tournament(C: Cfg, task: string, summaries: string[]): Promise<{ ranked: number[]; conf: number }> {
+  const n = summaries.length
+  const ids = Array.from({ length: n }, (_, i) => i)
+  if (n <= 1) return { ranked: ids, conf: 1 }
+  const limit = pLimit(C.cc)
+  const order = [...ids]
+  for (let i = order.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [order[i], order[j]] = [order[j], order[i]] }
+  const ring: Record<number, number> = Object.fromEntries(ids.map((i) => [i, 0]))
+  await Promise.all(order.map(async (id, i) => {
+    const b = order[(i + 1) % n]
+    const v = await judge(C, limit, task, summaries[id], summaries[b])
+    ring[v === "B" ? b : id]++
+  }))
+  const pivots = [...ids].sort((x, y) => ring[y] - ring[x]).slice(0, Math.min(C.topk, n))
+  const nonp = ids.filter((i) => !pivots.includes(i))
+  const pairs: [number, number][] = []
+  for (const np of nonp) for (const pv of pivots) pairs.push([np, pv])
+  for (let i = 0; i < pivots.length; i++) for (let j = i + 1; j < pivots.length; j++) pairs.push([pivots[i], pivots[j]])
+  const mass: Record<number, number> = Object.fromEntries(ids.map((i) => [i, 0]))
+  const games: Record<number, number> = Object.fromEntries(ids.map((i) => [i, 0]))
+  await Promise.all(pairs.map(async ([x, y]) => {
+    const votes = await Promise.all(Array.from({ length: C.k }, () => judge(C, limit, task, summaries[x], summaries[y])))
+    const na = votes.filter((v) => v === "A").length
+    const nb = votes.filter((v) => v === "B").length
+    const px = na + nb === 0 ? 0.5 : na / (na + nb)
+    mass[x] += px; mass[y] += 1 - px; games[x]++; games[y]++
+  }))
+  const ratio = (i: number) => (games[i] ? mass[i] / games[i] : ring[i] / Math.max(1, n - 1))
+  const ranked = [...ids].sort((a, b) => ratio(b) - ratio(a))
+  return { ranked, conf: ratio(ranked[0]) - ratio(ranked[1]) }
+}
+
+// ---- lean sandbox for sub-agent attempts ------------------------------------------------
+// Sub-agents run under XDG_CONFIG_HOME -> a provider-only config so they skip the user's MCP
+// servers and plugins (the slow part). Deps install once into the sandbox and cache forever.
+function leanConfig(C: Cfg): string {
+  return JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+    model: `${C.provider || "provider"}/${C.model}`,
+    permission: { edit: "allow", bash: "allow", webfetch: "allow" },
+    provider: {
+      [C.provider || "provider"]: {
+        npm: "@ai-sdk/openai-compatible",
+        name: C.provider || "provider",
+        options: { baseURL: C.url, apiKey: C.key },
+        models: { [C.model]: { name: C.model } },
+      },
+    },
+  }, null, 2)
+}
+
+function appFromAgent(_agent: string): string {
+  // The lean config is written under XDG/opencode/; opencode reads it, other agents ignore XDG.
+  return "opencode"
+}
+
+async function ensureLeanSandbox(C: Cfg, app: string): Promise<{ home: string; needsWarm: boolean }> {
+  const home = join(homedir(), ".cache", "agent-ultramode")
+  const appDir = join(home, app)
+  await mkdir(appDir, { recursive: true })
+  await writeFile(join(appDir, `${app}.json`), leanConfig(C))
+  return { home, needsWarm: !existsSync(join(appDir, "node_modules")) }
+}
+
+export const Ultra: Plugin = async (_input, options) => {
+  const C = buildCfg((options as Opts) ?? {})
+  const current = { model: "", url: "", key: "" }
+  const client = (_input as any)?.client
+  // load marker: lets us confirm which build actually loaded.
+  writeFile(join(homedir(), ".cache", "agent-ultramode-loaded.txt"), `ultra ${VERSION} loaded ${new Date().toISOString()}\n`).catch(() => {})
+
+  const ultra = tool({
+    description:
+      "Best-of-N with a verifier. Runs a coding/terminal task N times in isolated git worktrees, ranks the " +
+      "attempts with the same model as a verifier, and applies the winning diff when confident (otherwise " +
+      "reports the top candidates). Use for a task worth spending compute to get right the first time.",
+    args: {
+      task: tool.schema.string().describe("The task to solve N times and verify. Be specific."),
+    },
+    async execute(args, ctx) {
+      const task = String((args as any)?.task ?? "").trim()
+      if (!task) return "Pass a `task` to run."
+      const eff: Cfg = { ...C, model: C.model || current.model, url: C.url || current.url, key: C.key || current.key }
+      if (!eff.url || !eff.model) return "ultra could not resolve a verifier model. Set `model` in the plugin options, or send a message first so it can use your current model."
+
+      let dir = (ctx as any).worktree || (ctx as any).directory || ""
+      if (!dir) {
+        // some hosts omit directory/worktree on the tool context; resolve the repo root from cwd.
+        try { dir = (await git(process.cwd(), "rev-parse", "--show-toplevel")).trim() } catch { dir = process.cwd() }
+      }
+      let base: string
+      try { base = (await git(dir, "rev-parse", "HEAD")).trim() } catch { return "ultra needs a git repo with a HEAD to branch attempts from (run it inside your project)." }
+
+      const work = await mkdtemp(join(tmpdir(), "ultra-"))
+      const worktrees: string[] = []
+      const diffs: string[] = []
+      const summaries: string[] = []
+      const status = (title: string, body?: string) => {
+        try { ctx.metadata({ title, metadata: body ? { output: body } : {} }) } catch {}
+      }
+      // ctx.metadata renders in the web UI tool card; toasts render in the terminal TUI.
+      const toast = (message: string, variant: "info" | "success" | "warning" = "info") => {
+        try { client?.tui?.showToast?.({ body: { message: `ultra: ${message}`, variant, duration: 4000 } })?.catch?.(() => {}) } catch {}
+      }
+      try {
+        toast(`v${VERSION}: starting ${eff.n} attempts`)
+        // Each attempt runs the agent in a LEAN sandbox: XDG_CONFIG_HOME points opencode at a
+        // provider-only config (no MCP, no plugins, permission:allow), so an
+        // attempt is a fast model turn instead of booting the whole environment N times.
+        const app = appFromAgent(eff.agent)
+        const { home: leanHome, needsWarm } = await ensureLeanSandbox(eff, app)
+        // Shared: config dir (warm node_modules + lean config). Per-run: XDG_DATA/STATE/CACHE,
+        // so each sub-run gets its OWN opencode.db. One shared DB across the main session + N
+        // parallel runs deadlocks on the SQLite write lock (all idle, nothing written).
+        const baseEnv = {
+          ...process.env,
+          XDG_CONFIG_HOME: leanHome,
+          OPENCODE_DISABLE_DEFAULT_PLUGINS: "1",
+          OPENCODE_DISABLE_AUTOUPDATE: "1",
+          OPENCODE_DISABLE_MODELS_FETCH: "1",
+        }
+        const isolatedEnv = async (tag: string) => {
+          const d = join(work, `xdg-${tag}`)
+          await mkdir(d, { recursive: true }).catch(() => {})
+          return { ...baseEnv, XDG_DATA_HOME: d, XDG_STATE_HOME: d, XDG_CACHE_HOME: d }
+        }
+        const cmd = eff.agent.replace("{task}", task.replace(/"/g, '\\"'))
+
+        if (needsWarm) {
+          // First run on this machine installs the sandbox deps once (cached afterwards).
+          status(`ultra: one-time sandbox setup (installing ${app} sandbox deps, ~1-2 min)...`)
+          const warm = await mkdtemp(join(tmpdir(), "ultra-warm-"))
+          await execFileP("bash", ["-lc", "git init -q"], { cwd: warm }).catch(() => {})
+          const warmCmd = eff.agent.replace("{task}", "reply with exactly: ready. do not create or edit files.")
+          await execFileP("bash", ["-lc", `exec </dev/null; ${warmCmd}`], { cwd: warm, env: await isolatedEnv("warm"), timeout: eff.agentTimeoutMs, maxBuffer: 8 * 1024 * 1024 }).catch(() => {})
+          await rm(warm, { recursive: true, force: true }).catch(() => {})
+        }
+
+        // Create N detached worktrees off HEAD (serial: git worktree add takes a repo lock).
+        status(`ultra: preparing ${eff.n} isolated worktrees...`)
+        for (let i = 0; i < eff.n; i++) {
+          const wt = join(work, `attempt-${i}`)
+          await git(dir, "worktree", "add", "--detach", wt, base)
+          worktrees.push(wt)
+        }
+
+        // Run the agent in each worktree IN PARALLEL (lean sandbox keeps this cheap).
+        const limit = pLimit(Math.max(1, Math.min(eff.cc, eff.n)))
+        let done = 0
+        status(`ultra: running ${eff.n} attempts in parallel...`)
+        toast(`running ${eff.n} attempts in parallel`)
+        const outs = await Promise.all(worktrees.map((wt, i) => limit(async () => {
+          const env = await isolatedEnv(String(i))
+          let log = ""
+          try {
+            const { stdout, stderr } = await execFileP("bash", ["-lc", `exec </dev/null; ${cmd}`], { cwd: wt, env, timeout: eff.agentTimeoutMs, maxBuffer: 32 * 1024 * 1024, signal: ctx.abort })
+            log = (stdout || "") + (stderr || "")
+          } catch (e: any) { log = `agent error: ${e?.message || e}` }
+          await git(wt, "add", "-A").catch(() => {})
+          const diff = await git(wt, "diff", "--cached").catch(() => "")
+          done++
+          status(`ultra: ${done}/${eff.n} attempts done`, `attempt ${i}: ${diff ? diff.length + " diff chars" : "no changes"}`)
+          return { diff, summary: `AGENT LOG (tail):\n${log.slice(-1500)}\n\nDIFF:\n${diff.slice(0, 6000) || "(no changes)"}` }
+        })))
+        for (const o of outs) { diffs.push(o.diff); summaries.push(o.summary) }
+
+        if (diffs.every((d) => !d.trim())) {
+          return `ultra ran ${eff.n} attempts but none made any changes (all diffs empty). The sub-agent could not act: the task may be too ambiguous, or the sandbox model could not reach its endpoint. Try a more specific task, or check the model endpoint.`
+        }
+
+        status("ultra: verifying...")
+        toast(`verifying ${eff.n} candidates`)
+        const { ranked, conf } = await tournament(eff, task, summaries)
+        const best = ranked[0]
+
+        // Normalised added-lines of a diff, so we can tell when attempts AGREE on the same change.
+        const nonEmpty = diffs.filter((d) => d.trim()).length
+        // Apply the verifier's TOP pick when it is confident, OR when a majority of attempts
+        // produced a change (the task was solvable; the top-ranked diff is a good starting point
+        // and you review it before committing). Only mostly-empty runs are handed back as candidates.
+        const majority = nonEmpty >= Math.max(2, Math.ceil(eff.n / 2))
+        if ((conf >= eff.conf || majority) && diffs[best].trim()) {
+          const patch = join(work, "winner.patch")
+          await writeFile(patch, diffs[best])
+          const confNote = conf >= eff.conf ? `high confidence ${conf.toFixed(2)}` : `top pick of ${nonEmpty}/${eff.n}, margin ${conf.toFixed(2)}`
+          try {
+            await git(dir, "apply", "--3way", patch)
+            toast("applied the winning change", "success")
+            return `🏆 ultra applied the best of ${eff.n} attempts (${confNote}). The winning change is now in your working tree; review it before committing.`
+          } catch (e: any) {
+            return `ultra picked the best attempt (${confNote}) but the patch did not apply cleanly (${e?.message || e}). The diff:\n\n\`\`\`diff\n${diffs[best].slice(0, 6000)}\n\`\`\``
+          }
+        }
+        const top = ranked.slice(0, 3).map((i, r) => `### Candidate ${r + 1} (attempt ${i})\n\`\`\`diff\n${diffs[i].slice(0, 4000) || "(no changes)"}\n\`\`\``).join("\n\n")
+        return `ultra ran ${eff.n} attempts but most produced no usable change, so it applied nothing. Top candidates:\n\n${top}`
+      } finally {
+        for (const wt of worktrees) await git(dir, "worktree", "remove", "--force", wt).catch(() => {})
+        await rm(work, { recursive: true, force: true }).catch(() => {})
+      }
+    },
+  })
+
+  return {
+    tool: { ultra },
+    "chat.params": async (input: any) => {
+      try {
+        const id = input?.model?.id ?? input?.model?.modelID
+        const o = input?.provider?.options
+        if (id && o?.baseURL) { current.model = id; current.url = o.baseURL; if (o.apiKey) current.key = o.apiKey }
+      } catch {}
+    },
+    config: async (cfg: any) => {
+      cfg.command = {
+        ultra: {
+          description: "Best-of-N + verifier: run the task N times in isolated worktrees, apply the best. /ultra <task>",
+          template:
+            "Call the `ultra` tool exactly once, with `task` set to the request below. It runs the task several " +
+            "times in isolated git worktrees and verifies the results. When it returns, report to the user exactly " +
+            "what it did (applied the winner, or listed candidates) verbatim; do not re-do the task yourself.\n\nTask: $ARGUMENTS",
+        },
+        ...(cfg.command ?? {}),
+      }
+      // Register an "ultra" primary agent so it shows in the tab / agent list; selecting it
+      // routes each request through best-of-N. Sub-attempts run the default agent, so no recursion.
+      cfg.agent = {
+        ultra: {
+          description: "Best-of-N mode: run the request N times in isolated worktrees and apply the verified winner.",
+          mode: "primary",
+          color: "#A855F7",
+          prompt:
+            "You are in ULTRA mode (best-of-N with a same-model verifier). For the user's coding or terminal " +
+            "request, call the `ultra` tool exactly once with the full request as `task`. When it returns, report " +
+            "exactly what it did (applied the winner, or listed the candidates) verbatim; do not do the task yourself.",
+        },
+        ...(cfg.agent ?? {}),
+      }
+      try {
+        if (C.provider && cfg?.provider?.[C.provider]) {
+          const p = cfg.provider[C.provider]
+          if (!C.url && p.options?.baseURL) C.url = p.options.baseURL
+          if (!C.key && p.options?.apiKey) C.key = p.options.apiKey
+        }
+      } catch {}
+    },
+  }
+}
+
+export default Ultra