openvisio-agent 0.6.1 → 0.7.0

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.1",
+  "version": "0.7.0",
   "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

@@ -40,7 +40,12 @@ const CHAT_CHARTER = [
 ].join('\n')
 
 const CYCLE = CHAT_CHARTER + '\n\nRun one OpenVisio autonomy cycle: call poll_inbox and handle mentions + follow-ups. Reply in 1-3 sentences, @mention people by their EXACT full name, at most one reply per channel. Then stop.'
-const CYCLE_FAST = CHAT_CHARTER + '\n\nNew chat activity. If a specific mention FOR YOU is given above, reply to it with mcp__openvisio-team__post_message (once). Then call poll_inbox and look at .followUps — but reply ONLY to the ones actually directed at YOU (a question to you, or a reply to your own message); SKIP thread chatter aimed at someone else or another agent. Ignore .tasks/.claimable. AT MOST ONE reply per channel; answer several nudges together in ONE post; never repeat a reply you already sent. If asked for work you have no tool for, say so plainly and offer to file a ticket. Never invent progress. Reply in 1-3 sentences, no summary. Then stop.'
+const CYCLE_FAST = CHAT_CHARTER + '\n\n' + [
+  'New chat activity. Do EXACTLY ONE of these:',
+  '  • IF a specific mention/message FOR YOU is given above: reply to THAT ONE message exactly once with mcp__openvisio-team__post_message, then STOP. Do NOT call poll_inbox and do NOT answer anything else this cycle — you already have the message; polling would make you re-answer it and double-post.',
+  '  • IF NO specific mention is given above: call poll_inbox and reply only to items truly directed at YOU (a question to you, or a reply to your own message) — SKIP chatter aimed at someone else / another agent, ignore .tasks/.claimable, at most one reply per channel.',
+  'Post ONE message total for the thing you are answering — compose it fully, then send once. Never send a reply and then a "better" version; never repeat a reply you already sent. Be sure of your answer before sending. If asked for work you have no tool for, say so plainly and offer to file a ticket. 1-3 sentences, no summary. Then stop.',
+].join('\n')
 
 // ── CODE agents (--workdir given): full file + Bash + git/gh surface. ─────────
 // A stable "who you are / how you work" charter prepended to every code cycle.
@@ -75,10 +80,11 @@ const CODE_FULL = CODE_CHARTER + '\n\n' + [
 ].join('\n')
 
 const CODE_FAST = CODE_CHARTER + '\n\n' + [
-  'New chat activity. If a specific mention FOR YOU is given above, reply to it FIRST with mcp__openvisio-team__post_message (once) — before any Bash.',
-  'Then poll_inbox and handle .followUps ONLY when the reply is directed at YOU (asks you something, or responds to your own message) — SKIP thread chatter aimed at someone else / another agent. At most one reply per channel, and never repeat a reply you already sent.',
-  'If a message asks YOU for real CODE work, do the WHOLE job now — branch (checkout -B agent/<slug>), edit, run tests, commit, push your branch, open a PR (gh pr create), then reply with the PR link and @mention the requester by exact full name. Never push to main, never --force, never merge.',
-  'Do NOT promise and stop — finish and report in THIS cycle. Reply 1-3 sentences, no summary. Then stop.',
+  'New chat activity. Do EXACTLY ONE of these:',
+  '  • IF a specific mention/message FOR YOU is given above: reply to THAT ONE message exactly once with mcp__openvisio-team__post_message, then STOP. Do NOT call poll_inbox and do NOT answer anything else this cycle — polling would re-surface the same message and make you double-post.',
+  '  • IF NO specific mention is given above: call poll_inbox and reply only to items directed at YOU (asks you something, or responds to your own message) — SKIP chatter aimed at someone else / another agent; at most one reply per channel.',
+  'If the message asks YOU for real CODE work, do the WHOLE job now — branch (checkout -B agent/<slug>), edit, run tests, commit, push your branch, open a PR (gh pr create), then reply once with the PR link and @mention the requester by exact full name. Never push to main, never --force, never merge.',
+  'Post ONE message for the thing you are answering — send it once; never a reply then a "better" version; never repeat a reply you already sent; be sure before you send. Do NOT promise and stop — finish and report in THIS cycle. 1-3 sentences, no summary. Then stop.',
 ].join('\n')
 
 // ── Workspace-ethics cycles (both chat-only + code agents) ───────────────────
@@ -130,6 +136,11 @@ export async function runWatch({ flags }) {
   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
@@ -143,12 +154,11 @@ 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) || '')
 
   // Backend agents (connect --backend) drive autonomy over a real-time WS instead
@@ -162,7 +172,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) || '')
@@ -171,15 +181,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
@@ -274,9 +339,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.
@@ -342,7 +407,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.
@@ -396,11 +463,11 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, mcpConfig, wor
       const parent = msg.parent_id != null ? msg.parent_id : (msg.parentId != null ? msg.parentId : null)
       const threadRoot = parent != null ? parent : mid
       // De-dupe: the same mention re-delivered (reconnect replay / dup fan-out) must
-      // NOT trigger a second reply to the same message.
-      if (mid != null) {
-        if (seenMentions.has(mid)) { log('agent:mention (dup ' + mid + ') — skipped'); return }
-        seenMentions.add(mid); if (seenMentions.size > 500) seenMentions.clear()
-      }
+      // NOT trigger a second reply. Key by message id, or a channel+text signature
+      // when the payload carries no id.
+      const dedupeKey = mid != null ? 'id:' + mid : 'sig:' + (cid != null ? cid : '?') + '|' + text.slice(0, 100)
+      if (seenMentions.has(dedupeKey)) { log('agent:mention (dup) — skipped'); return }
+      seenMentions.add(dedupeKey); if (seenMentions.size > 500) seenMentions.clear()
       // Under-the-hood model control from chat (view / switch the model the agent runs).
       const mcmd = cid != null ? parseModelCmd(text) : null
       if (mcmd) {
@@ -425,7 +492,7 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, mcpConfig, wor
       }
       log('agent:mention in channel ' + (cid != null ? cid : '?') + (threadRoot != null ? ' (thread ' + threadRoot + ')' : ''))
       const ctx = cid != null
-        ? `You were @mentioned in OpenVisio channel ${cid}${who ? ` by "${who}"` : ''}: "${text}". This mention is FOR YOU — reply once with mcp__openvisio-team__post_message as your FIRST action — arguments: channel_id ${cid}${threadRoot != null ? `, parent_id ${threadRoot} (reply IN THAT THREAD, do not start a new top-level message)` : ''}, plus agent_identifier + agent_api_key from the AUTH line above, and a 1-3 sentence reply. FIRST read the recent messages in this thread: if you already answered this, or it turns out another agent was the one addressed, do NOT post. Be sure of your answer before sending — do not reply then correct yourself.${who ? ` To @mention them back, write their EXACT full name "@${who}" (a mention only links when the name matches exactly — "@${who.split(' ')[0]}" alone will NOT).` : ''} You already have the message here — do NOT poll_inbox to find it.`
+        ? `You were @mentioned in OpenVisio channel ${cid}${who ? ` by "${who}"` : ''}: "${text}". This mention is FOR YOU. Send EXACTLY ONE reply with mcp__openvisio-team__post_message — arguments: channel_id ${cid}${threadRoot != null ? `, parent_id ${threadRoot} (reply IN THAT THREAD, do not start a new top-level message)` : ''}, plus agent_identifier + agent_api_key from the AUTH line above, and a 1-3 sentence reply. Compose the whole answer, then post it ONCE — do NOT post a first reply and then a revised/"better" one. FIRST read the recent messages in this thread: if you already answered this, or another agent was the one addressed, do NOT post at all. Be sure of your answer before sending.${who ? ` To @mention them back, write their EXACT full name "@${who}" (a mention only links when the name matches exactly — "@${who.split(' ')[0]}" alone will NOT).` : ''} You ALREADY have the message here — do NOT poll_inbox, and after your single reply, STOP.`
         : undefined
       void drain('fast', ctx)
     } else if (k === 'error') {
@@ -479,10 +546,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
@@ -587,7 +654,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`)