openvisio-agent 0.6.2 → 0.7.1

package/bin/cli.mjs

@@ -24,8 +24,8 @@ const HELP = `openvisio-agent ${VERSION}
 Connect your coding agent to an OpenVisio team.
 
 Usage:
-  openvisio-agent connect <ovs_code> --host <url> [--name "<agent>"] [--mcp-url <url>]
-  openvisio-agent connect --backend <url> --key <api-key> --id <identifier> [--name "<agent>"] [--ws <wss-url>] [--mcp-url <url>]
+  openvisio-agent connect <ovs_code> --host <url> [--name "<agent>"] [--mcp-url <url>] [--agent claude|opencode]
+  openvisio-agent connect --backend <url> --key <api-key> --id <identifier> [--name "<agent>"] [--ws <wss-url>] [--mcp-url <url>] [--agent claude|opencode]
   openvisio-agent watch   --name <agent> [--install] [--workspace <dir>] [--chat-only] [--model <m>] [--chat-model <m>] [--debug]
   openvisio-agent --help | --version
 
@@ -50,6 +50,9 @@ connect --backend
                      pushes its agent/* branch and opens PRs. Defaults to
                      ~/openvisio-workspace; point it at an existing clones folder to
                      reuse those. (--workdir is an accepted alias.)
+    --agent <name>   the coding-agent RUNTIME the cycles run on: claude (Claude Code,
+                     default) or opencode (opencode.ai). opencode is authenticated
+                     separately (opencode auth login) and uses provider/model ids.
     --chat-only      disable code work — chat/ticket tools only.
     --model <m>      the model the agent runs on (opus | sonnet | haiku | a full
                      claude-… id). Defaults to sonnet — cost-effective, so the agent
@@ -94,6 +97,24 @@ function ensureAgentInstalled() {
   spawnSync('npm', ['i', '-g', 'openvisio-agent@latest'], { stdio: 'inherit', shell: process.platform === 'win32' })
 }
 
+// The chosen coding-agent RUNTIME the cycles run on. Default claude.
+function agentFlag(flags) {
+  const a = String(flags.agent || flags.runtime || 'claude').toLowerCase()
+  if (a !== 'claude' && a !== 'opencode') fail(`Unknown --agent "${a}". Supported runtimes: claude | opencode.`)
+  return a
+}
+
+// opencode runtime: ensure the `opencode` CLI exists (best-effort install), and
+// remind about its one-time auth. Unlike Claude Code we don't register an MCP here
+// — the watcher writes an `opencode.json` with the openvisio-team server at runtime.
+function ensureOpencode() {
+  if (onPath('opencode')) return
+  info('opencode not found on PATH — installing (npm i -g opencode-ai)…')
+  spawnSync('npm', ['i', '-g', 'opencode-ai'], { stdio: 'inherit', shell: process.platform === 'win32' })
+  if (!onPath('opencode')) info('Could not auto-install opencode. Install it — https://opencode.ai/docs/ — then run:  opencode auth login')
+  else info('Installed opencode. Authenticate it once if you haven\'t:  opencode auth login')
+}
+
 async function runConnect({ positional, flags }) {
   if (flags.backend) return runConnectBackend({ positional, flags })
   const token = positional[0] || flags.token
@@ -107,21 +128,28 @@ async function runConnect({ positional, flags }) {
   const mcpUrl = (flags['mcp-url'] && String(flags['mcp-url'])) || srvMcp || stripSlash(host) + '/api/agent/mcp'
   const name = (flags.name && String(flags.name)) || 'openvisio-team'
   const slug = slugify(name)
+  const agent = agentFlag(flags)
 
-  const claude = ensureClaude()
-
-  // Register with Claude Code — remove any stale entry first so a changed URL sticks.
-  mcpReplace(claude, ['--transport', 'http', 'openvisio-team', mcpUrl, '--header', `Authorization: Bearer ${key}`])
-
-  // A scoped MCP config (for the watcher's --strict-mcp-config) + a saved profile.
-  const mcpCfg = mcpConfigPath(slug)
-  writeJson(mcpCfg, { mcpServers: { 'openvisio-team': { type: 'http', url: mcpUrl, headers: { Authorization: `Bearer ${key}` } } } }, true)
+  // Register the openvisio-team MCP with the chosen runtime.
+  let mcpCfg = ''
+  if (agent === 'claude') {
+    const claude = ensureClaude()
+    // Remove any stale entry first so a changed URL sticks, then add at user scope.
+    mcpReplace(claude, ['--transport', 'http', 'openvisio-team', mcpUrl, '--header', `Authorization: Bearer ${key}`])
+    // A scoped MCP config for the watcher's --strict-mcp-config.
+    mcpCfg = mcpConfigPath(slug)
+    writeJson(mcpCfg, { mcpServers: { 'openvisio-team': { type: 'http', url: mcpUrl, headers: { Authorization: `Bearer ${key}` } } } }, true)
+  } else {
+    ensureOpencode() // the watcher writes opencode.json with the remote MCP at runtime
+  }
   const wsWorkdir = flags.workdir === true ? process.cwd() : flags.workdir ? String(flags.workdir) : flags.workspace ? String(flags.workspace) : ''
-  writeJson(configPath(slug), { host: stripSlash(host), key, mcpUrl, name, slug, mcpConfig: mcpCfg, ...(wsWorkdir ? { workspace: wsWorkdir } : {}), ...(flags['chat-only'] ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
+  writeJson(configPath(slug), { host: stripSlash(host), key, mcpUrl, name, slug, ...(mcpCfg ? { mcpConfig: mcpCfg } : {}), ...(agent !== 'claude' ? { agent } : {}), ...(wsWorkdir ? { workspace: wsWorkdir } : {}), ...(flags['chat-only'] ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
 
   ok(`Connected "${name}" to ${host}.`)
   info()
-  info('Claude Code now has the openvisio-team tools. Run  /mcp  in Claude Code to confirm.')
+  info(agent === 'opencode'
+    ? 'Runtime: opencode. The watcher writes an opencode.json with the openvisio-team tools; make sure opencode is authenticated (opencode auth login).'
+    : 'Claude Code now has the openvisio-team tools. Run  /mcp  in Claude Code to confirm.')
   info()
   info('To let it work on its own (reply to mentions, pick up tickets, AND do real')
   info('coding — it clones/branches/pushes and opens PRs out of the box):')
@@ -160,6 +188,7 @@ async function runConnectBackend({ flags }) {
 
   const name = (flags.name && String(flags.name)) || 'backend-agent'
   const slug = slugify(name)
+  const agent = agentFlag(flags)
 
   // Code workspace preference (optional). CODE mode is on by default; this only
   // pins WHERE the agent works. Persisted so the always-on `watch` reuses it.
@@ -177,15 +206,19 @@ async function runConnectBackend({ flags }) {
 
   let mcpConfig = ''
   if (mcpUrl) {
-    const claude = ensureClaude()
-    // Backend agents authenticate with the agent header pair, not a Bearer JWT.
-    const hdr = ['--header', `x-agent-api-key: ${apiKey}`, '--header', `x-agent-identifier: ${identifier}`]
-    mcpReplace(claude, ['--transport', 'http', 'openvisio-team', mcpUrl, ...hdr])
-    mcpConfig = mcpConfigPath(slug)
-    writeJson(mcpConfig, { mcpServers: { 'openvisio-team': { type: 'http', url: mcpUrl, headers: { 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier } } } }, true)
+    if (agent === 'claude') {
+      const claude = ensureClaude()
+      // Backend agents authenticate with the agent header pair, not a Bearer JWT.
+      const hdr = ['--header', `x-agent-api-key: ${apiKey}`, '--header', `x-agent-identifier: ${identifier}`]
+      mcpReplace(claude, ['--transport', 'http', 'openvisio-team', mcpUrl, ...hdr])
+      mcpConfig = mcpConfigPath(slug)
+      writeJson(mcpConfig, { mcpServers: { 'openvisio-team': { type: 'http', url: mcpUrl, headers: { 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier } } } }, true)
+    } else {
+      ensureOpencode() // the watcher writes opencode.json with the remote MCP at runtime
+    }
   }
 
-  writeJson(configPath(slug), { mode: 'backend', backend, apiKey, identifier, name, slug, wsUrl, mcpUrl, mcpConfig, ...(workdir ? { workspace: workdir } : {}), ...(chatOnly ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
+  writeJson(configPath(slug), { mode: 'backend', backend, apiKey, identifier, name, slug, wsUrl, mcpUrl, mcpConfig, ...(agent !== 'claude' ? { agent } : {}), ...(workdir ? { workspace: workdir } : {}), ...(chatOnly ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
   // A sourceable env file, matching the setup snippet OpenVisio shows.
   const envPath = join(OV_DIR, `${slug}.env`)
   mkdirSync(OV_DIR, { recursive: true })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openvisio-agent",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "description": "Connect your coding agent (Claude Code) to an OpenVisio team — MCP tools + optional autonomy — in one command. No shell scripts.",
   "type": "module",
   "bin": {

package/src/watch.mjs

@@ -5,7 +5,7 @@
 // than written to disk from a pasted heredoc.
 
 import { spawn, spawnSync } from 'node:child_process'
-import { writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { writeFileSync, mkdirSync, existsSync, readFileSync, unlinkSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, dirname } from 'node:path'
 import { OV_DIR, DEFAULT_WORKSPACE, readConfig, writeJson, configPath, onPath, fail, ok, info, slugify, stripSlash, chmodSafe } from './lib.mjs'
@@ -29,6 +29,7 @@ const REPLY_DISCIPLINE = [
   '  • IS IT FOR YOU? Act ONLY on messages addressed to YOU — an @mention of your exact name, a direct question to you, or a reply to something YOU said or did. If a DIFFERENT agent or person was @mentioned or asked to do something, STAY OUT: do not answer for them and do not pick up their task. When it is not yours, posting nothing is the correct move.',
   '  • NO DUPLICATES. Before you post, scan the recent thread/channel for what YOU already said. If you already replied to or acknowledged this exact request, do NOT post again. One acknowledgement per task; one answer per question. While a task is in progress, post again ONLY when you have something genuinely NEW (a result, a link, a real blocker) — never re-post "on it".',
   '  • BE SURE BEFORE YOU SPEAK. Do not claim something is possible, done, or broken until you have actually verified it — call the tool, read the code, check the real state. Never assert then contradict yourself. If you are unsure, verify FIRST, then give ONE clear, final answer instead of thinking out loud across several messages.',
+  '  • NO INVENTED HISTORY. You have NO memory beyond the messages visible in THIS thread and what your tools return right now. Never fabricate past events, competitions, conversations, results, links, PR numbers, deploy URLs, or figures. If you are asked about something you have no actual record of, say plainly "I don\'t have a record of that" — do NOT make one up to play along or be helpful. Only state things you can see or verify.',
 ].join('\n')
 
 // ── CHAT-ONLY agents (no --workdir): chat/ticket tools, no code surface. ──────
@@ -131,11 +132,39 @@ const SESSION_IDLE_MS = 1200000
 const MAX_CYCLE_MS = 240000
 const MAX_CODE_CYCLE_MS = 900000
 
+// Refuse to run a SECOND watcher for the same agent. Two watchers connect to the
+// WS as the same agent and BOTH reply to every mention — the #1 cause of duplicate
+// (and contradicting, if the two are different versions) messages. A pid lock file
+// in ~/.openvisio makes the second start fail fast instead. Stale locks (dead pid)
+// are taken over. Returns { release } or { conflict: <pid> }.
+function acquireSingleInstance(key) {
+  const lockPath = join(OV_DIR, 'watch-' + key + '.lock')
+  try {
+    mkdirSync(OV_DIR, { recursive: true })
+    if (existsSync(lockPath)) {
+      const pid = parseInt(String(readFileSync(lockPath, 'utf8')).trim(), 10)
+      if (pid && pid !== process.pid) {
+        let alive = false
+        try { process.kill(pid, 0); alive = true } catch (e) { alive = !!(e && e.code === 'EPERM') }
+        if (alive) return { conflict: pid }
+      }
+    }
+    writeFileSync(lockPath, String(process.pid))
+  } catch { /* if the lock can't be written, don't block the agent from running */ }
+  const release = () => { try { if (parseInt(String(readFileSync(lockPath, 'utf8')).trim(), 10) === process.pid) unlinkSync(lockPath) } catch { /* already gone */ } }
+  return { release }
+}
+
 export async function runWatch({ flags }) {
   const slug = flags.name ? slugify(String(flags.name)) : null
   const saved = slug ? readConfig(slug) : null
   const claude = String(flags.claude || onPath('claude') || 'claude')
   const mcpConfig = String(flags['mcp-config'] || (saved && saved.mcpConfig) || '')
+  // Which coding-agent runtime drives the cycles: Claude Code (warm stream-json
+  // session) or opencode (headless `opencode run` per cycle). Default claude.
+  const agent = String(flags.agent || flags.runtime || (saved && saved.agent) || 'claude').toLowerCase()
+  if (agent !== 'claude' && agent !== 'opencode') fail(`Unknown --agent "${agent}". Supported runtimes: claude | opencode.`)
+  const mcpUrl = String(flags['mcp-url'] || (saved && saved.mcpUrl) || '')
   // Code mode is the DEFAULT: an agent lives on the user's laptop and should just be
   // able to work across the org's repos with no per-repo setup. So `workdir` resolves
   // to (in order) an explicit --workdir/--workspace, the saved workspace, or the
@@ -149,14 +178,26 @@ export async function runWatch({ flags }) {
   const workdir = chatOnly ? '' : (explicitWorkdir || (saved && (saved.workspace || saved.workdir)) || DEFAULT_WORKSPACE)
   if (workdir) { try { mkdirSync(workdir, { recursive: true }) } catch { /* best-effort; spawn will surface a real problem */ } }
 
-  // Model the agent runs on. Default SONNET (cost-effective) rather than whatever
-  // `claude` defaults to — the agent shouldn't burn Opus tokens on routine chatter.
-  // Optional --chat-model runs the lighter chat/mention cycles on an even cheaper
-  // model while code cycles stay on the main one. Both persisted + live-changeable
-  // via the in-chat `/model` command (see loopBackendWs).
-  const model = String(flags.model || (saved && saved.model) || 'sonnet')
+  // Model the agent runs on. For Claude Code default SONNET (cost-effective) rather
+  // than whatever `claude` defaults to. For opencode, models are `provider/model`
+  // and multi-provider, so default to empty (use opencode's own configured default)
+  // unless set. Optional --chat-model runs the lighter chat/mention cycles cheaper.
+  const model = String(flags.model || (saved && saved.model) || (agent === 'opencode' ? '' : 'sonnet'))
   const chatModel = String(flags['chat-model'] || (saved && saved.chatModel) || '')
 
+  // ONE watcher per agent. A second one (e.g. a manual `watch` alongside the
+  // background service, or a stale service) is the #1 cause of duplicate replies:
+  // both connect as the same agent and both answer every mention. Refuse to start.
+  if (!flags.install) {
+    const lock = acquireSingleInstance(slug || 'openvisio')
+    if (lock.conflict) {
+      fail(`Another openvisio-agent watcher for "${slug || 'openvisio'}" is already running (pid ${lock.conflict}).\n` +
+        `  Two watchers for the same agent BOTH reply to every mention — that is what causes duplicate/contradicting messages.\n` +
+        `  Stop the other one (kill ${lock.conflict}), or rely on ONLY the background service. Refusing to start a second.`)
+    }
+    process.on('exit', () => { try { lock.release && lock.release() } catch { /* noop */ } })
+  }
+
   // Backend agents (connect --backend) drive autonomy over a real-time WS instead
   // of REST-polling the frontend relay. Detected by the saved mode / a --ws flag.
   const backendMode = (saved && saved.mode === 'backend') || !!flags.ws
@@ -168,7 +209,7 @@ export async function runWatch({ flags }) {
     if (!apiKey || !identifier) fail('No saved backend credentials for that agent.\n  Run `openvisio-agent connect --backend …` first, or pass --key and --id.')
     assertWebSocket(fail)
     if (flags.install) return installService({ slug: slug || 'openvisio', claude, mcpConfig, workdir })
-    return loopBackendWs({ wsUrl, apiKey, identifier, slug: slug || 'openvisio', claude, mcpConfig, workdir, model, chatModel, debug: !!flags.debug })
+    return loopBackendWs({ wsUrl, apiKey, identifier, slug: slug || 'openvisio', claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug: !!flags.debug })
   }
 
   const host = stripSlash(flags.host || (saved && saved.host) || '')
@@ -177,15 +218,70 @@ export async function runWatch({ flags }) {
 
   if (flags.install) return installService({ slug: slug || 'openvisio', claude, mcpConfig, workdir })
 
-  return loop({ host, key, slug: slug || 'openvisio', claude, mcpConfig, workdir, model, chatModel, debug: !!flags.debug })
+  return loop({ host, key, slug: slug || 'openvisio', claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug: !!flags.debug })
+}
+
+// ── opencode cycle runner ─────────────────────────────────────────────────────
+// opencode (opencode.ai) has no persistent stream-json protocol like Claude Code,
+// so each cycle is a headless `opencode run <prompt> --auto [--model provider/model]`.
+// The openvisio-team MCP is declared in an `opencode.json` written into the run cwd
+// (opencode reads it from there). `--auto` approves tool use non-interactively.
+// Same { runCycle, canCode } contract as the Claude runner.
+function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, maxCycleMs, log, debug, model }) {
+  // opencode reads opencode.json from its CWD: the code workspace, or a dedicated
+  // per-agent dir for chat-only agents.
+  const cwd = workdir || join(OV_DIR, 'opencode-' + (cfgKey || 'agent'))
+  const bin = onPath('opencode') || 'opencode'
+  let configured = false
+  const ensureConfig = () => {
+    if (configured) return
+    configured = true
+    try {
+      mkdirSync(cwd, { recursive: true })
+      if (mcpUrl) {
+        writeJson(join(cwd, 'opencode.json'), {
+          $schema: 'https://opencode.ai/config.json',
+          mcp: { 'openvisio-team': { type: 'remote', url: mcpUrl, enabled: true, ...(mcpHeaders && Object.keys(mcpHeaders).length ? { headers: mcpHeaders } : {}) } },
+        }, true)
+      } else {
+        log('WARNING: no --mcp-url — opencode has no openvisio-team tools to act with. Re-connect with --mcp-url.')
+      }
+    } catch (e) { log('opencode config write failed: ' + (e && e.message ? e.message : e)) }
+  }
+
+  function runCycle(prompt, cycleModel) {
+    return new Promise((resolve) => {
+      ensureConfig()
+      const m = cycleModel || model
+      const args = ['run', prompt, '--auto', ...(m ? ['--model', m] : [])]
+      let child = null, done = false
+      const finish = (o) => { if (done) return; done = true; clearTimeout(timer); resolve(o) }
+      const timer = setTimeout(() => {
+        log('opencode cycle TIMED OUT after ' + Math.round(maxCycleMs / 1000) + 's — killing')
+        try { child && child.kill() } catch { /* gone */ }
+        finish({ type: 'result', subtype: 'timeout' })
+      }, maxCycleMs)
+      log('running opencode cycle…' + (m ? ' [' + m + ']' : ''))
+      try { child = spawn(bin, args, { cwd, stdio: ['ignore', debug ? 'inherit' : 'ignore', 'inherit'] }) }
+      catch (e) { log('opencode spawn failed: ' + (e && e.message ? e.message : e) + ' — is opencode installed? (npm i -g opencode-ai, then `opencode auth login`)'); return finish({ type: 'result', subtype: 'spawn-failed' }) }
+      child.on('exit', (code) => { log('opencode cycle done (' + (code === 0 ? 'ok' : 'exit ' + code) + ')'); finish({ type: 'result', subtype: code === 0 ? 'ok' : 'error' }) })
+      child.on('error', (e) => { log('opencode error: ' + (e && e.message ? e.message : e)); finish({ type: 'result', subtype: 'error' }) })
+    })
+  }
+
+  log('opencode runner ready' + (model ? ' [model ' + model + ']' : '') + (canCode ? ' [CODE workspace ' + cwd + ']' : ' [CHAT-ONLY — cfg ' + cwd + ']'))
+  return { runCycle, canCode }
 }
 
 // ── Claude Code warm-session cycle runner (shared by the REST + WS loops) ─────
 // One persistent stream-json session, poked with a prompt per cycle. Recycled
 // after MAX_TURNS or SESSION_IDLE_MS. Returns { runCycle, canCode }.
-function createCycleRunner({ claude, mcpConfig, workdir, log, debug, model }) {
+function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model }) {
   const canCode = !!workdir
   const maxCycleMs = canCode ? MAX_CODE_CYCLE_MS : MAX_CYCLE_MS
+  // opencode drives cycles differently — a headless `opencode run` per cycle rather
+  // than a persistent stream-json session. Same { runCycle, canCode } contract.
+  if (agent === 'opencode') return createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, maxCycleMs, log, debug, model })
   let child = null
   // The model the CURRENT session was spawned with. runCycle can pass a different
   // model per cycle (cheap for chat, stronger for code) — a change recycles the
@@ -280,9 +376,9 @@ function createCycleRunner({ claude, mcpConfig, workdir, log, debug, model }) {
 // over the WS; each pushes ONE Claude cycle. Serialized (one cycle at a time) — events
 // arriving while busy are coalesced into a single follow-up cycle so a burst doesn't
 // stack up N sessions. Plus a one-time intro on first connect and a daily catch-up sweep.
-function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, mcpConfig, workdir, model, chatModel, debug }) {
+function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug }) {
   const log = (m) => process.stdout.write('[ws ' + new Date().toISOString() + '] ' + m + '\n')
-  const { runCycle, canCode } = createCycleRunner({ claude, mcpConfig, workdir, log, debug, model })
+  const { runCycle, canCode } = createCycleRunner({ claude, agent, mcpUrl, mcpHeaders: { 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier }, cfgKey: identifier, mcpConfig, workdir, log, debug, model })
   const fullPrompt = canCode ? CODE_FULL : CYCLE
   const fastPrompt = canCode ? CODE_FAST : CYCLE_FAST
   // Live model state — changeable at runtime by the in-chat `/model` command.
@@ -348,7 +444,9 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, mcpConfig, wor
   const normalizeModel = (s) => {
     const x = String(s || '').toLowerCase().replace(/[.,!?]+$/, '')
     if (x === 'opus' || x === 'sonnet' || x === 'haiku') return x
-    return /^claude-[a-z0-9.\-\[\]]+$/i.test(x) ? x : null
+    if (/^claude-[a-z0-9.\-\[\]]+$/i.test(x)) return x
+    // opencode models are provider/model (e.g. anthropic/claude-sonnet-4, openai/gpt-4o).
+    return /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9.\-:]*$/i.test(x) ? x : null
   }
   // Optional target tier: "chat"/"lite" → chat cycles only, "code"/"full" → code
   // cycles only, absent → both.
@@ -485,10 +583,10 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, mcpConfig, wor
 }
 
 // ── the warm loop ────────────────────────────────────────────────────────────
-function loop({ host, key, slug, claude, mcpConfig, workdir, model, chatModel, debug }) {
+function loop({ host, key, slug, claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug }) {
   const log = (m) => process.stdout.write('[warm ' + new Date().toISOString() + '] ' + m + '\n')
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
-  const { runCycle, canCode } = createCycleRunner({ claude, mcpConfig, workdir, log, debug, model })
+  const { runCycle, canCode } = createCycleRunner({ claude, agent, mcpUrl, mcpHeaders: { Authorization: 'Bearer ' + key }, cfgKey: slug, mcpConfig, workdir, log, debug, model })
   const fullPrompt = canCode ? CODE_FULL : CYCLE
   const fastPrompt = canCode ? CODE_FAST : CYCLE_FAST
   const liteModel = chatModel || model // cheaper model for chat/quick cycles
@@ -593,7 +691,8 @@ export function installService({ slug, workdir }) {
   const bin = onPath('openvisio-agent') || 'openvisio-agent'
   const nodeDir = dirname(process.execPath)
   const claudeBin = onPath('claude')
-  const runPath = [nodeDir, claudeBin ? dirname(claudeBin) : '', '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin'].filter(Boolean).join(':')
+  const opencodeBin = onPath('opencode')
+  const runPath = [nodeDir, claudeBin ? dirname(claudeBin) : '', opencodeBin ? dirname(opencodeBin) : '', join(homedir(), '.opencode', 'bin'), '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin'].filter(Boolean).join(':')
   const args = ['watch', '--name', slug, ...(workdir ? ['--workdir', workdir] : [])]
   mkdirSync(OV_DIR, { recursive: true })
   const logFile = join(OV_DIR, `${slug}.log`)