agy-mcp-bridge 0.1.27 → 0.1.29

package/README.md

@@ -16,7 +16,7 @@ agy-mcp-bridge                                       # serves http://127.0.0.1:3
 
 Fastest first run: from inside the project you want to work on, `agy-mcp-bridge --workspace .` grants the current directory **for this run only** and does not touch config. Repeat the flag for several folders; a wrong path, or the bridge's own install directory, stops startup.
 
-`agy-mcp-bridge check | setup codex|claude|both | delegation on|off|status | skill install | config | update | help`. `--open` launches the web UI in your browser. Config and task history live in the user data directory (`%APPDATA%\agy-mcp-bridge`, `~/.config/agy-mcp-bridge`, `~/Library/Application Support/agy-mcp-bridge`; override with `BRIDGE_HOME`), so an upgrade never deletes them. `agy-mcp-bridge config` prints the real paths.
+`agy-mcp-bridge check | setup codex|claude|freebuff|both | delegation on|off|status | skill install | config | update | help`. `--open` launches the web UI in your browser. Config and task history live in the user data directory (`%APPDATA%\agy-mcp-bridge`, `~/.config/agy-mcp-bridge`, `~/Library/Application Support/agy-mcp-bridge`; override with `BRIDGE_HOME`), so an upgrade never deletes them. `agy-mcp-bridge config` prints the real paths.
 
 At startup the bridge probes each CLI. An agent that is missing or unsupported is marked unavailable and takes no task; if `agy` is unavailable, the default agent silently becomes the next enabled one, so check `agents_list` after changing machines. Priority and per-agent switches live under `agents` in `config/workspaces.json`. Verified against real agent execution on `agy` 1.4.3, 1.4.7, 1.4.8 and 1.4.9; other 1.4.x patches run with a logged warning; other majors are refused.
 
@@ -41,6 +41,8 @@ Claude Code:
 claude mcp add --transport http --scope local antigravity 'http://127.0.0.1:3000/mcp'
 ```
 
+Freebuff CLI is a **client only**, never a delegated agent: its CLI is an interactive TUI with no headless mode, so no adapter can drive it. `agy-mcp-bridge setup freebuff` prints the stdio entry it reads (`.agents/mcp.json`); `setup freebuff --apply [--project <dir>]` merges that one entry into `~/.agents/mcp.json` after showing the change and asking, keeping every other server and taking a backup. Freebuff starts that bridge as a **child process**, so closing Freebuff cancels a task still running; for work that must outlive the client, run the HTTP server and point Freebuff at `/mcp` instead (only stdio is documented for Freebuff). [docs/FREEBUFF-INTEGRATION.md](docs/FREEBUFF-INTEGRATION.md)
+
 Then call `antigravity_environment` from a fresh session — that is the proof; `codex mcp list` and `/mcp` only show configuration. Closing or disconnecting a client does not stop the server or cancel an accepted task. Reconnect, read `recent_tasks`, and reuse the task id instead of delegating the same work twice.
 
 ## Delegate
@@ -88,18 +90,19 @@ Whether a profile really is a second account depends on the adapter. A `codex` p
 
 Four rules about these ids are easy to get wrong, all measured rather than inferred:
 
-- `agents.enabled` must list **every profile id** you declare, not just the adapters. A profile missing there is silently disabled, and a pool of such members then refuses with `Unknown agent "<pool id>"` — a message that names the pool while the broken line is `enabled`. Omitting `enabled` entirely enables everything; the example keeps the key so you can see it exists, which means a new profile has to be added to that list too.
+- `agents.enabled` must list **every profile id** you declare, not just the adapters. A profile missing there is silently disabled, and a pool of such members then refuses with `Pool "<pool id>" has no healthy member right now` — a message that names the pool while the broken line is `enabled`. Omitting `enabled` entirely enables everything; the example keeps the key so you can see it exists, which means a new profile has to be added to that list too.
 - A `codex` profile also needs the base `codex` id in `enabled`, because that is what makes the bridge probe the codex CLI at all. Without it the profile is unavailable **and reports no warning**, so `agents_list` shows a dead agent with no reason.
 - `model` on a profile is read only for a `codex` profile; an `antigravity` profile runs with the model you choose in the web UI.
 - `priority` and `enabled` accept a pool id without complaining, but the default agent is matched against agent ids only — a pool there silently selects nothing. Name the pool in the `agent` argument of a task instead.
 
-`agents.pools.<id>` groups profiles for quota handling. Delegating to a pool id picks the first healthy member. When a member stops with something that reads like an exhausted quota or rate limit, the bridge marks it cooling for `quota_cooldown_seconds` and re-runs **the same task** on the next member — each member at most once per task, after which the task fails instead of looping. The replaced attempt is kept on the record as `attempts[]` (agent, error, exit, log tails) so a reviewer can still see why the first CLI stopped, and the retry keeps holding the execution lock rather than releasing and re-taking it, so no second ordinary task slips into the gap.
+`agents.pools.<id>` groups profiles for quota handling. Delegating to a pool id picks the first healthy member. When a member stops with something that reads like an exhausted quota or rate limit, the bridge marks it cooling for `quota_cooldown_seconds` and re-runs **the same task** on the next member — each member at most once per task, after which the task fails instead of looping. The replaced attempt is kept on the record as `attempts[]` (agent, error, exit, log tails, and for a worktree task the `scope` it had reached) so a reviewer can still see why the first CLI stopped and which files it left behind — the retry reuses the same worktree, so the task's own `scope` is the sum of both attempts — and the retry keeps holding the execution lock rather than releasing and re-taking it, so no second ordinary task slips into the gap.
 
 The owner's Settings reach an `antigravity` **profile** exactly as they reach `antigravity`, because they key on the adapter behind the id, not on the id: the model, the permission level, the effort, and the soft deadline with its `--log-file` and its extended `--print-timeout` are all on the command line of a profile task. Read that as a widening, not a cosmetic fix — before, a profile was locked to the CLI's own defaults and could not be given `--dangerously-skip-permissions` at all; now your permission level applies to its tasks too, so a profile is no more restricted than the agent it comes from.
 
-Two knobs are opt-in because they widen what the bridge can reach. Neither is reachable from a task, and neither stays invisible: the codex pair is reported in `agents_list` warnings, and the XERJ pair in `/api/xerj/status` plus the refusal `code_search` gives while it is off.
+Three knobs are opt-in because they widen what the bridge can reach. None is reachable from a task, and none stays invisible: the codex pair and `opencode_auto_approve` are reported in `agents_list` warnings, and the XERJ pair in `/api/xerj/status` plus the refusal `code_search` gives while it is off.
 
 - `codex_sandbox: "danger-full-access"` / `codex_ask_for_approval: "never"` — readable from the bridge's own config file only. No task, tool argument or MCP client can ask for them, and `--ask-for-approval` is passed where codex accepts it (before `exec`).
+- `agents.opencode_auto_approve: true` — passes `opencode run --auto`, which approves every permission OpenCode's own config does not deny. OpenCode itself is opt-in (list it in `agents.enabled`). A task's `autonomy: "full"` never adds the flag, for the same reason it never changes the codex sandbox: `autonomy` is an instruction, not a permission grant.
 - `xerj.enabled` / `xerj.auto_reference` — both default to `false`. Turning them on sends task text to another local service and can place a retrieved passage inside the prompt an agent follows, which is a decision for the machine's owner, not for a delegating client.
 
 ## Missions
@@ -164,6 +167,7 @@ Pushing or merging to `main` runs CI and, when it passes, publishes to npm autom
 - [docs/VERIFICATION.md](docs/VERIFICATION.md) — client CLI versions and live connection results.
 - [docs/MULTI-AGENT-PLAN.md](docs/MULTI-AGENT-PLAN.md) — the multi-agent roadmap and per-phase status.
 - [docs/HANDOFF.md](docs/HANDOFF.md) — open work (Job Object, POSIX E2E, worktree TTL) with mutation-test evidence.
+- [docs/FREEBUFF-INTEGRATION.md](docs/FREEBUFF-INTEGRATION.md) — why Freebuff is a client and not an agent, the measurement behind that, and what `setup freebuff` writes.
 - [docs/PROMPTS.md](docs/PROMPTS.md) — review and follow-up task prompts.
 - [skills/antigravity-bridge/SKILL.md](skills/antigravity-bridge/SKILL.md), [skills/mission-orchestrator/SKILL.md](skills/mission-orchestrator/SKILL.md) and [docs/SKILL-EVAL.md](docs/SKILL-EVAL.md) — the client-side contract and manual evaluation cases.
 

package/config/workspaces.example.json

@@ -11,10 +11,12 @@
   "max_parallel_worktrees": 2,
   "default_autonomy": "auto",
   "agents": {
-    "priority": ["antigravity", "codex"],
-    "enabled": ["antigravity", "codex", "codex-work", "codex-backup"],
+    "priority": ["antigravity", "codex", "opencode"],
+    "enabled": ["antigravity", "codex", "opencode", "codex-work", "codex-backup", "opencode-work"],
     "codex_sandbox": "workspace-write",
     "codex_ask_for_approval": "on-request",
+    "opencode_executable": "opencode",
+    "opencode_model": "opencode/big-pickle",
     "profiles": {
       "codex-work": {
         "adapter": "codex",
@@ -29,11 +31,19 @@
         "env": {
           "CODEX_HOME": "C:/Users/name/.codex-backup"
         }
+      },
+      "opencode-work": {
+        "adapter": "opencode",
+        "label": "OpenCode (Work)",
+        "env": {
+          "XDG_DATA_HOME": "C:/Users/name/.opencode-work/data",
+          "XDG_CONFIG_HOME": "C:/Users/name/.opencode-work/config"
+        },
+        "model": "opencode/big-pickle"
       }
     },
     "pools": {
       "codex-smart-pool": {
-        "strategy": "quota-adaptive",
         "members": ["codex-work", "codex-backup"],
         "hard_task_profile": "codex-work",
         "quota_cooldown_seconds": 900

package/dist/src/agents/antigravity.js

@@ -1,6 +1,6 @@
 import { finalEnvelope, invocationFor } from '../antigravity/invocation.js';
 import { extractStats } from '../usage.js';
-import { isQuotaError } from './quota.js';
+import { isQuotaError, isStrongQuotaError } from './quota.js';
 const CAPABILITIES = ['code', 'review', 'test', 'research', 'long-run'];
 export function antigravityAdapter(executable, defaultTransport, options = {}) {
     return {
@@ -51,7 +51,7 @@ export function antigravityAdapter(executable, defaultTransport, options = {}) {
             // A stream result that is not the expected envelope is reported by field name, because that is what tells the owner to turn step progress off.
             const fields = transport === 'argv' ? '' : ` (stream result fields: ${Object.keys(envelope).slice(0, 12).join(', ') || 'none'}; if step progress is on, turn it off in Settings to return to the JSON mode)`;
             const finalErr = typeof envelope.error === 'string' ? envelope.error : `CLI did not provide a complete successful response${fields}`;
-            const quotaHit = isQuotaError(raw.stderr) || isQuotaError(finalErr) || isQuotaError(raw.stdout);
+            const quotaHit = isQuotaError(raw.stderr) || isQuotaError(finalErr) || isStrongQuotaError(raw.stdout);
             return { ...result, error: finalErr, isQuotaExceeded: quotaHit };
         }
     };

package/dist/src/agents/codex.js

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { isQuotaError } from './quota.js';
+import { isQuotaError, isStrongQuotaError } from './quota.js';
 import { startProcess, terminateOwned } from '../antigravity/process.js';
 const CAPABILITIES = ['code', 'review', 'test', 'research', 'long-run'];
 const REQUIRED_FLAGS = ['--json', '--sandbox', '--cd', '--output-last-message', '--ephemeral', '--skip-git-repo-check'];
@@ -78,7 +78,7 @@ export function codexAdapter(command, options = {}) {
                 return { ...result, error: `Codex was terminated (${raw.signal})` };
             const stderrTail = raw.stderr.trim().split(/\r?\n/).filter(Boolean).at(-1);
             const finalErr = errors.at(-1) ?? stderrTail?.slice(0, 500) ?? 'Codex did not provide a final message';
-            const quotaHit = isQuotaError(raw.stderr) || isQuotaError(finalErr) || isQuotaError(raw.stdout);
+            const quotaHit = isQuotaError(raw.stderr) || isQuotaError(finalErr) || isStrongQuotaError(raw.stdout);
             return { ...result, error: finalErr, isQuotaExceeded: quotaHit };
         }
     };

package/dist/src/agents/opencode.js

@@ -0,0 +1,161 @@
+import { startProcess, terminateOwned } from '../antigravity/process.js';
+import { isQuotaError } from './quota.js';
+export const CAPABILITIES = ['code', 'review', 'test', 'research', 'long-run'];
+// Verified against opencode v2.2.5: `opencode run` reads the message from stdin and, with `--format json`, writes one JSON event per line.
+const REQUIRED_FLAGS = ['--format', '--model', '--auto', '--standalone'];
+const MAX_RESPONSE_CHARS = 1024 * 1024;
+export function opencodeAdapter(command, options = {}) {
+    return {
+        id: options.id ?? 'opencode',
+        label: options.label ?? 'OpenCode',
+        family: 'opencode',
+        capabilities: CAPABILITIES,
+        buildInvocation(task) {
+            // `run` is the subcommand, so its flags follow it. The message goes over stdin: argv is capped (about 32 KB on Windows),
+            // a prompt starting with "-" would be read as a flag, and splitting it into words would lose its line breaks.
+            // The working directory is the process cwd, set by the launcher.
+            // `--standalone` gives the run a private server. Without it `opencode run` hands the task to the shared OpenCode
+            // background service (the one the desktop app keeps running): measured on v2.2.5, cancelling the client then left the
+            // agent working, its shell was a child of the service and not of the run the bridge can reap, and the session showed up
+            // in the owner's OpenCode. With it, killing the run stopped the work and left no process behind.
+            const args = ['run', '--standalone', '--format', 'json'];
+            const model = task.model ?? options.model;
+            if (model)
+                args.push('--model', model);
+            // Without --auto opencode still edits files and runs shell commands in the workspace without asking (measured on v2.2.5);
+            // --auto also approves what its config would otherwise ask about, such as paths outside the workspace.
+            // Only the owner can turn it on (agents.opencode_auto_approve): the task's `autonomy` is chosen by the delegating client and is an
+            // instruction to the agent, never a permission grant, so it must not reach a flag that takes approval away.
+            if (options.autoApprove)
+                args.push('--auto');
+            return {
+                executable: command.executable,
+                args: [...command.prefixArgs, ...args],
+                stdin: `${task.prompt}\n`,
+                customEnv: options.env
+            };
+        },
+        compactLine(line) {
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                return line; /* not an event: kept, it may be the only clue to a failure */
+            }
+            if (!event || typeof event !== 'object' || Array.isArray(event))
+                return line;
+            const { type, part } = event;
+            // parseResult reads text, error and step_finish events, so those stay whole.
+            if (type === 'text' || type === 'error' || type === 'step_finish')
+                return line;
+            if (type === 'step_start')
+                return null;
+            // A tool event carries the file or command output it produced: keep which tool ran and how it ended, not the payload.
+            if (type === 'tool_use')
+                return JSON.stringify({ type, part: { tool: part?.tool, state: { status: part?.state?.status } } });
+            return line.length > 2000 ? JSON.stringify({ type }) : line;
+        },
+        async parseResult(raw) {
+            const texts = [];
+            const errors = [];
+            let turns = 0;
+            let finishReason = null;
+            let inputTokens = 0;
+            let outputTokens = 0;
+            let sawTokens = false;
+            for (const line of raw.stdout.split(/\r?\n/)) {
+                if (!line.trim())
+                    continue;
+                let event;
+                try {
+                    const value = JSON.parse(line);
+                    if (!value || typeof value !== 'object' || Array.isArray(value))
+                        continue;
+                    event = value;
+                }
+                catch {
+                    continue; /* A non-JSON line stays in the raw log but cannot change the result. */
+                }
+                const part = event.part;
+                if (event.type === 'text' && typeof part?.text === 'string')
+                    texts.push(part.text);
+                else if (event.type === 'error') {
+                    const error = event.error;
+                    errors.push(typeof error?.message === 'string' ? error.message : typeof error?.type === 'string' ? error.type : 'OpenCode reported an error');
+                }
+                else if (event.type === 'step_finish') {
+                    turns++;
+                    if (typeof part?.reason === 'string')
+                        finishReason = part.reason;
+                    const tokens = part?.tokens;
+                    if (typeof tokens?.input === 'number') {
+                        inputTokens += tokens.input;
+                        sawTokens = true;
+                    }
+                    if (typeof tokens?.output === 'number') {
+                        outputTokens += tokens.output;
+                        sawTokens = true;
+                    }
+                }
+            }
+            // The last text event is the final answer; earlier ones are narration between tool calls.
+            const response = texts.at(-1)?.slice(0, MAX_RESPONSE_CHARS).trim() || null;
+            const base = {
+                success: false, response, error: null, cliStatus: finishReason, numTurns: turns || null, deniedActions: [],
+                stats: sawTokens ? { usage: { input_tokens: inputTokens, output_tokens: outputTokens }, agy_duration_seconds: null, num_turns: turns || null, steps: turns || null } : undefined
+            };
+            if (raw.exitCode === 0 && !errors.length && response)
+                return { ...base, success: true, numTurns: turns || 1 };
+            if (raw.signal)
+                return { ...base, error: `OpenCode was terminated (${raw.signal})` };
+            const stderrTail = raw.stderr.trim().split(/\r?\n/).filter(Boolean).at(-1)?.slice(0, 500);
+            const finalErr = errors.at(-1) ?? stderrTail ?? (raw.exitCode === 0 ? 'OpenCode did not provide a final message' : `OpenCode exited ${raw.exitCode}`);
+            // Only a failed run can be out of quota: a successful answer that merely mentions "429" must not trigger a failover.
+            const quotaHit = isQuotaError(finalErr) || isQuotaError(raw.stderr) || errors.some(isQuotaError);
+            return { ...base, error: finalErr, cliStatus: quotaHit ? 'quota_exceeded' : base.cliStatus ?? `exit ${raw.exitCode}`, isQuotaExceeded: quotaHit };
+        }
+    };
+}
+export function opencodeAgent(command, status, options = {}) {
+    return { adapter: opencodeAdapter(command, options), status, enabled: true, prefixArgs: command.prefixArgs };
+}
+function capture(command, args, cwd, extraEnvPassthrough) {
+    return new Promise((resolve, reject) => {
+        const child = startProcess(command.executable, [...command.prefixArgs, ...args], cwd, { extraEnvPassthrough });
+        let text = '';
+        let exceeded = false;
+        const timer = setTimeout(() => { exceeded = true; void terminateOwned(child).catch(reject); }, 10000);
+        const append = (chunk) => { if (text.length < 32768)
+            text += chunk.toString().slice(0, 32768 - text.length); };
+        child.stdout.on('data', append);
+        child.stderr.on('data', append);
+        child.once('error', error => { clearTimeout(timer); reject(error); });
+        child.once('close', code => { clearTimeout(timer); exceeded ? reject(new Error('OpenCode inspection timed out')) : resolve({ code, text }); });
+    });
+}
+/** Non-interactive `opencode run --format json` is the only contract this adapter relies on. */
+export async function detectOpenCode(command, opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const extra = opts.extraEnvPassthrough ?? [];
+    const status = (available, version, warnings) => ({
+        id: 'opencode', label: 'OpenCode', available, version, executable: command.executable, capabilities: CAPABILITIES, warnings
+    });
+    try {
+        const version = await capture(command, ['--version'], cwd, extra);
+        const help = await capture(command, ['run', '--help'], cwd, extra);
+        const parsed = version.text.trim().split(/\r?\n/)[0]?.replace(/^opencode\s+/i, '').replace(/^v/i, '') || null;
+        if (version.code !== 0)
+            return status(false, null, ['opencode --version failed']);
+        if (help.code !== 0)
+            return status(false, parsed, ['opencode run --help failed']);
+        const missing = REQUIRED_FLAGS.filter(flag => !new RegExp(`(?:^|[\\s,])${flag}(?=[\\s,]|$)`).test(help.text));
+        if (missing.length)
+            return status(false, parsed, [`OpenCode CLI is missing required run flags: ${missing.join(', ')}`]);
+        return status(true, parsed, []);
+    }
+    catch (error) {
+        return status(false, null, [`OpenCode CLI could not be inspected: ${error instanceof Error ? error.message : 'unknown error'}`]);
+    }
+}
+//# sourceMappingURL=opencode.js.map

package/dist/src/agents/quota.js

@@ -1,24 +1,41 @@
-export const QUOTA_ERROR_PATTERNS = [
+import { readFileSync, renameSync, writeFileSync } from 'node:fs';
+/**
+ * Wording that is hard to meet in ordinary prose or code: a provider says it, an agent rarely writes it by accident.
+ * These are the only patterns trusted on stdout, where an agent's own message ("I fixed the rate limit handler") lives.
+ */
+export const STRONG_QUOTA_PATTERNS = [
     /insufficient_quota/i,
-    /rate[_\s-]?limit(?:ed|_exceeded)?/i,
     /quota[_\s-]?exceeded/i,
     /credits?[_\s-]?exhausted/i,
     /check your plan and billing/i,
+    /exceeded your current quota/i,
+    /resource_exhausted/i
+];
+/** Everything above, plus wording that error text uses but prose and stack traces also do. Only for stderr and the CLI's own error field. */
+export const QUOTA_ERROR_PATTERNS = [
+    ...STRONG_QUOTA_PATTERNS,
+    /rate[_\s-]?limit(?:ed|_exceeded)?/i,
     /billing details/i,
     /too many requests/i,
     /credit limit/i,
     /model[_\s-]?capacity/i,
     /\boverloaded\b/i,
-    /exceeded your current quota/i,
-    /resource_exhausted/i,
-    /\b429\b/
+    // A bare 429 also matches line numbers (`parser.ts:429`) and counts, so it has to be named as a status.
+    /\b(?:http|status|code|error)\b[^\n]{0,20}\b429\b/i,
+    /\b429\s+(?:too many|rate|error|client error)/i
 ];
-/** Check if stdout/stderr/error text indicates an account quota exhaustion or rate limit. */
+/** Check if stderr or a CLI error field indicates an account quota exhaustion or rate limit. */
 export function isQuotaError(text) {
     if (!text)
         return false;
     return QUOTA_ERROR_PATTERNS.some(pattern => pattern.test(text));
 }
+/** The stricter check for stdout, which carries the agent's own words as well as the CLI's output. */
+export function isStrongQuotaError(text) {
+    if (!text)
+        return false;
+    return STRONG_QUOTA_PATTERNS.some(pattern => pattern.test(text));
+}
 const HARD_KEYWORDS = /(?:refactor|architecture|concurrency|tái cấu trúc|bảo mật|tối ưu|redesign|deadlock|race condition|migration|distributed)/i;
 /** Assess whether a task is considered 'hard' (high complexity, multi-file, or architectural). */
 export function isHardTask(input) {
@@ -31,18 +48,48 @@ export function isHardTask(input) {
         return true;
     if (HARD_KEYWORDS.test(fullText))
         return true;
+    // Reasoning effort is not a signal here: it is an owner setting for the whole bridge, not a property of one task.
     if ((input.timeout_seconds ?? 0) >= 600)
         return true;
-    if (input.effort === 'high')
-        return true;
     return false;
 }
+const MAX_PERSISTED_COOLDOWNS = 200;
 export class ProfileHealthTracker {
     cooldowns = new Map();
+    file = null;
+    /**
+     * Keeps cooldowns across a restart: without it an account that has just run out of quota is picked again by the next
+     * task. Anything unreadable or already expired is dropped, which only ever means "available". Writing is best effort.
+     */
+    attach(file) {
+        this.file = file;
+        try {
+            const value = JSON.parse(readFileSync(file, 'utf8'));
+            if (typeof value !== 'object' || value === null || Array.isArray(value))
+                return;
+            const now = Date.now();
+            for (const [id, expiresAt] of Object.entries(value).slice(0, MAX_PERSISTED_COOLDOWNS)) {
+                if (id.length <= 64 && typeof expiresAt === 'number' && Number.isFinite(expiresAt) && expiresAt > now)
+                    this.cooldowns.set(id, expiresAt);
+            }
+        }
+        catch { /* no file, or unreadable: every profile starts available */ }
+    }
+    save() {
+        if (!this.file)
+            return;
+        try {
+            const temporary = `${this.file}.tmp`;
+            writeFileSync(temporary, JSON.stringify(Object.fromEntries(this.cooldowns)), { mode: 0o600 });
+            renameSync(temporary, this.file);
+        }
+        catch { /* the cooldown still holds in memory; only its survival of a restart is lost */ }
+    }
     /** Mark a profile as exhausted / in cooldown until now + durationSeconds. */
     markCooldown(profileId, durationSeconds = 900) {
         const expiresAt = Date.now() + durationSeconds * 1000;
         this.cooldowns.set(profileId, expiresAt);
+        this.save();
     }
     /** Check if a profile is currently available (not cooled down). */
     isAvailable(profileId) {
@@ -57,7 +104,8 @@ export class ProfileHealthTracker {
     }
     /** Clear cooldown for testing or explicit manual recovery. */
     clearCooldown(profileId) {
-        this.cooldowns.delete(profileId);
+        if (this.cooldowns.delete(profileId))
+            this.save();
     }
     /**
      * Intelligently select the best profile from a pool based on task difficulty and health status.
@@ -74,7 +122,7 @@ export class ProfileHealthTracker {
         if (isHard && pool.hard_task_profile && healthyMembers.includes(pool.hard_task_profile)) {
             return pool.hard_task_profile;
         }
-        // 'quota-adaptive', 'priority-failover', and the current round-robin stub: first healthy in pool order
+        // The one selection rule a pool has: the first healthy member, in the order of `members`.
         return healthyMembers[0];
     }
 }

package/dist/src/agents/registry.js

@@ -1,8 +1,10 @@
 import { resolveCommand } from '../antigravity/process.js';
 import { antigravityAdapter } from './antigravity.js';
 import { codexAgent, detectCodex } from './codex.js';
-const KNOWN = ['antigravity', 'codex'];
-const DEFAULT_PRIORITY = ['antigravity', 'codex'];
+import { opencodeAgent, opencodeAdapter, detectOpenCode, CAPABILITIES } from './opencode.js';
+const KNOWN = ['antigravity', 'codex', 'opencode'];
+const DEFAULT_PRIORITY = ['antigravity', 'codex', 'opencode'];
+// OpenCode is opt-in: list it in agents.enabled. Probing it by default would add an extra CLI to every pool for owners who never asked for it.
 const DEFAULT_ENABLED = ['antigravity', 'codex'];
 export async function createAgentRegistry(config, antigravity) {
     const settings = config.agents ?? {};
@@ -51,6 +53,28 @@ export async function createAgentRegistry(config, antigravity) {
         sandbox: settings.codex_sandbox,
         askForApproval: settings.codex_ask_for_approval
     }));
+    const opencodeEnabled = enabled.includes('opencode');
+    let opencodeStatus = {
+        id: 'opencode', label: 'OpenCode', available: false, version: null, executable: null,
+        capabilities: CAPABILITIES, warnings: ['Disabled in the bridge config']
+    };
+    let opencodeCommand = { executable: 'opencode', prefixArgs: [], source: 'opencode' };
+    if (opencodeEnabled) {
+        try {
+            opencodeCommand = await resolveCommand(settings.opencode_executable ?? 'opencode');
+            opencodeStatus = await detectOpenCode(opencodeCommand, { cwd: process.cwd(), extraEnvPassthrough: config.extra_env_passthrough });
+        }
+        catch (error) {
+            opencodeStatus = { ...opencodeStatus, warnings: [`OpenCode CLI not found: ${error instanceof Error ? error.message : 'unknown error'}`] };
+        }
+    }
+    const opencodeAutoWarning = 'Agent "opencode" is configured to auto-approve permissions (opencode_auto_approve): tasks run with opencode --auto';
+    if (opencodeEnabled && settings.opencode_auto_approve)
+        opencodeStatus = { ...opencodeStatus, warnings: [...opencodeStatus.warnings, opencodeAutoWarning] };
+    agents.push(opencodeAgent(opencodeCommand, opencodeStatus, {
+        model: settings.opencode_model,
+        autoApprove: settings.opencode_auto_approve
+    }));
     if (settings.profiles) {
         for (const [profileId, profile] of Object.entries(settings.profiles)) {
             const isProfileEnabled = enabled.includes(profileId) || (!settings.enabled && true);
@@ -121,6 +145,39 @@ export async function createAgentRegistry(config, antigravity) {
                     sandbox, askForApproval, env: profile.env
                 }));
             }
+            else if (adapterType === 'opencode') {
+                let cmd = opencodeCommand.executable;
+                let prefixArgs = opencodeCommand.prefixArgs;
+                let available = opencodeStatus.available;
+                let version = opencodeStatus.version;
+                if (profile.executable) {
+                    try {
+                        const resolved = await resolveCommand(profile.executable);
+                        cmd = resolved.executable;
+                        prefixArgs = resolved.prefixArgs;
+                        const detected = await detectOpenCode(resolved, { cwd: process.cwd(), extraEnvPassthrough: config.extra_env_passthrough });
+                        available = detected.available;
+                        version = detected.version;
+                        profileWarnings.push(...detected.warnings);
+                    }
+                    catch (error) {
+                        available = false;
+                        profileWarnings.push(`OpenCode CLI not found: ${error instanceof Error ? error.message : 'unknown error'}`);
+                    }
+                }
+                const status = {
+                    id: profileId, label, available: isProfileEnabled && available,
+                    version: version || null, executable: cmd || null,
+                    capabilities: CAPABILITIES,
+                    warnings: isProfileEnabled
+                        ? [...opencodeStatus.warnings.filter(w => !w.includes('Disabled') && w !== opencodeAutoWarning), ...profileWarnings, ...(settings.opencode_auto_approve ? [opencodeAutoWarning.replace('"opencode"', `"${profileId}"`)] : [])]
+                        : profileWarnings
+                };
+                agents.push({
+                    adapter: opencodeAdapter({ executable: cmd, prefixArgs, source: 'opencode-profile' }, { id: profileId, label, model: profile.model ?? settings.opencode_model, env: profile.env, autoApprove: settings.opencode_auto_approve }),
+                    status, enabled: isProfileEnabled, prefixArgs
+                });
+            }
         }
     }
     const usable = (agent) => agent.enabled && agent.status.available;

package/dist/src/antigravity/process.js

@@ -30,23 +30,31 @@ export async function resolveCommand(configured) {
         // A shim that exists but cannot be resolved safely is a definitive failure: silently falling through
         // to the next PATH entry would hide why the configured command cannot run.
         if (process.platform === 'win32' && (extension === '.cmd' || extension === '.bat')) {
-            const script = await shimEntry(resolved);
-            return { executable: process.execPath, prefixArgs: [script], source: resolved };
+            const entry = await shimEntry(resolved);
+            // A shim of a natively packaged CLI (OpenCode) points at its own .exe: run that directly, not through Node.
+            if (path.extname(entry).toLowerCase() === '.exe')
+                return { executable: entry, prefixArgs: [], source: resolved };
+            return { executable: process.execPath, prefixArgs: [entry], source: resolved };
         }
         if (process.platform === 'win32' && extension !== '.exe')
             continue;
         return { executable: resolved, prefixArgs: [], source: resolved };
     }
-    throw new Error(`Command not found: ${configured}${process.platform === 'win32' ? ' (a native .exe or an npm .cmd shim pointing at a local .js entry is required)' : ''}`);
+    throw new Error(`Command not found: ${configured}${process.platform === 'win32' ? ' (a native .exe or an npm .cmd shim pointing at a local .js or .exe entry is required)' : ''}`);
 }
-const SHIM_ENTRY = /(?:%dp0%|%~dp0)[\\/]([^"\r\n]+?\.(?:js|mjs|cjs))/gi;
+const SHIM_ENTRY = /(?:%dp0%|%~dp0)[\\/]([^"\r\n]+?\.(?:js|mjs|cjs|exe))/gi;
 async function shimEntry(shim) {
     const text = await readFile(shim, 'utf8');
     if (text.length > 65536)
         throw new Error('Unsupported .cmd shim: file is too large');
     const directory = path.dirname(shim);
-    for (const match of text.matchAll(SHIM_ENTRY)) {
-        const candidate = path.resolve(directory, match[1]);
+    // A script entry wins over an .exe one. npm's own shim for a Node CLI names `%dp0%\node.exe` (its "use the node beside me"
+    // line) before the script line, and where node.exe sits next to the shim that line would otherwise be taken as the entry
+    // and the script dropped. A shim of a natively packaged CLI has no script, so its .exe is then the entry.
+    const isExe = (entry) => path.extname(entry).toLowerCase() === '.exe';
+    const entries = [...text.matchAll(SHIM_ENTRY)].map(match => match[1]).sort((a, b) => Number(isExe(a)) - Number(isExe(b)));
+    for (const entry of entries) {
+        const candidate = path.resolve(directory, entry);
         if (!inside(directory, candidate))
             continue;
         try {
@@ -66,12 +74,22 @@ export async function findExecutable(configured) {
 }
 export function childEnvironment(parent, extra = []) {
     const explicit = new Set(extra.map(key => key.toUpperCase()));
-    const base = /^(PATH|HOME|USERPROFILE|APPDATA|LOCALAPPDATA|TEMP|TMP|TMPDIR|SYSTEMROOT|COMSPEC|LANG|LC_.*|XDG_.*|HTTP_PROXY|HTTPS_PROXY|NO_PROXY)$/i;
+    // PATHEXT is how PowerShell and cmd resolve `git` to git.exe; without it an agent's shell cannot find any program by its bare name.
+    const base = /^(PATH|PATHEXT|HOME|USERPROFILE|APPDATA|LOCALAPPDATA|TEMP|TMP|TMPDIR|SYSTEMROOT|COMSPEC|LANG|LC_.*|XDG_.*|HTTP_PROXY|HTTPS_PROXY|NO_PROXY)$/i;
     return Object.fromEntries(Object.entries(parent).filter(([key, value]) => value !== undefined &&
         (explicit.has(key.toUpperCase()) || (base.test(key) && !/TOKEN|SECRET|PASSWORD|API_KEY/i.test(key)))));
 }
+/**
+ * A parent that starts the bridge with a trimmed environment (an MCP client's stdio launcher keeps only a handful of variables)
+ * leaves PATHEXT unset, and then PowerShell cannot resolve `git` to git.exe. A value the parent did set wins over this default.
+ */
+export function withWindowsDefaults(env, platform = process.platform) {
+    if (platform !== 'win32' || Object.keys(env).some(key => key.toUpperCase() === 'PATHEXT'))
+        return env;
+    return { ...env, PATHEXT: '.COM;.EXE;.BAT;.CMD' };
+}
 export function startProcess(executable, args, cwd, options = {}) {
-    const env = { ...childEnvironment(process.env, options.extraEnvPassthrough), ...(options.customEnv ?? {}) };
+    const env = withWindowsDefaults({ ...childEnvironment(process.env, options.extraEnvPassthrough), ...(options.customEnv ?? {}) });
     const child = spawn(executable, args, {
         cwd, env, shell: false, windowsHide: true, detached: process.platform !== 'win32',
         stdio: ['pipe', 'pipe', 'pipe']