openvisio-agent 0.25.4 → 0.25.6

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## Unreleased
+
+## [0.25.6] — 2026-09-21
+
+- Keep healthy backend watchers event-driven after their connection recovery pass instead of polling every project for tasks and activity every 30 seconds.
+- Stop idle journal heartbeats, derive Studio liveness from watcher PID locks, and apply model-setting changes through filesystem notifications instead of two-second polling.
+- Add semantic icons and status colors to Agent Studio's watcher, model-settings, and agent-removal actions.
+
+## [0.25.5] — 2026-09-21
+
+- Add Gemini CLI and Qwen Code as coding-agent providers through their native ACP modes.
+- Centralize provider commands, installation, authentication guidance, model defaults, Studio model discovery, and cleanup in one runtime registry.
+- Give every ACP provider the same authenticated OpenVisio MCP bridge, watcher lifecycle, workspace isolation, session reuse, and live Studio model controls.
+- Stop OpenCode ACP children as soon as their cycle finishes, leaving only the lightweight event watcher running while idle.
+
 ## [0.25.4] — 2026-09-21
 
 - Route the backend's `agent:message` events through the same verified recipient, deduplication, queue, model, and delivery path as targeted mentions.

package/README.md

@@ -1,6 +1,6 @@
 # openvisio-agent
 
-Connect your coding agent (**Claude Code, Codex, or OpenCode**) to an [OpenVisio](https://openvisio.app) team — in one command. No shell scripts, no `curl | bash`.
+Connect your coding agent (**Claude Code, Codex, OpenCode, Gemini CLI, or Qwen Code**) to an [OpenVisio](https://openvisio.app) team — in one command. No shell scripts, no `curl | bash`.
 
 **New here?** Start with the [user guide](USER_GUIDE.md) for setup, everyday work, Agent Studio, and troubleshooting.
 
@@ -17,6 +17,8 @@ codex login
 npx -y openvisio-agent@latest connect ovs_YOURCODE --host https://your-openvisio.app --name "Ada" --agent codex
 ```
 
+Gemini CLI and Qwen Code use the same setup and watcher. Choose `--agent gemini` or `--agent qwen`; setup installs the selected CLI when it is missing. Launch that CLI once to complete its normal authentication flow.
+
 That's it. Your selected runtime now has the team's tools (channels, tickets, docs, search) during autonomy cycles.
 
 ## What it does
@@ -26,7 +28,7 @@ That's it. Your selected runtime now has the team's tools (channels, tickets, do
 ### `connect <ovs_code> --host <url>`
 
 1. Redeems the **single-use** setup code for your agent key (`POST /api/agent/setup/exchange`). The code is short-lived and one-time, so it's inert if it leaks into your shell history.
-2. Configures the `openvisio-team` MCP for the selected runtime. Claude Code is registered globally; Codex and OpenCode receive an isolated MCP configuration for each autonomy cycle.
+2. Configures the `openvisio-team` MCP for the selected runtime. Claude Code is registered globally; ACP runtimes receive an isolated authenticated MCP configuration for each autonomy cycle.
 3. Saves a scoped config under `~/.openvisio/` (chmod `600`) for the optional watcher.
 
 Options: `--name "<agent>"` (label), `--mcp-url <url>` (override the MCP endpoint).
@@ -60,7 +62,7 @@ Then `watch --name ada` auto-detects the backend agent and runs a WebSocket loop
 
 Runs the **autonomy loop** — the agent replies to @mentions and picks up tickets on its own. It cheaply polls an inbox endpoint (no model spend when idle) and starts isolated runtime sessions only when something new arrives.
 
-Codex and OpenCode cycles run through Mastra's ACP harness. Codex uses the packaged `codex-acp` adapter and reuses the machine's existing ChatGPT/Codex login; OpenCode uses its native `opencode acp` server. Each accepted ticket gets its own ACP session and worktree. Mastra Memory stores ticket/thread context in local libSQL under `~/.openvisio/`, while a compact JSON ledger retains only exact replay, cancellation, and delivery keys.
+Codex, OpenCode, Gemini CLI, and Qwen Code cycles run through one Mastra ACP harness. Codex uses the packaged `codex-acp` adapter; the others use their native ACP servers. Every provider receives the same authenticated team tools, workspace isolation, cancellation, and Studio model-selection path. Each accepted ticket gets its own ACP session and worktree. Mastra Memory stores ticket/thread context in local libSQL under `~/.openvisio/`, while a compact JSON ledger retains only exact replay, cancellation, and delivery keys.
 
 Backend watchers also provide four local context tools through the authenticated MCP bridge:
 
@@ -79,7 +81,7 @@ The integration follows Mastra's [semantic memory](https://mastra.ai/docs/memory
 
 Model selections are stable. Exact IDs (including reasoning effort) are preserved. An unsuffixed ACP model may resolve once to the same model with `medium` effort; the watcher saves that exact selection. Unavailable selections produce an explicit error rather than switching generations or families. Claude versioned IDs are preserved, with automatic family fallbacks disabled. Codex uses the configured chat model for replies.
 
-Backend/BYO watchers reconcile immediately whenever the process starts or the WebSocket connects. A direct MCP session discovers and caches the backend's actual `tools/list` response, then uses available tools such as `list_agents`, `list_projects`, `list_tasks`, `list_task_types`, and `list_activity` to recover assigned tasks and recent mention activity missed while offline. Team discovery is shared by every runtime provider: structured MCP results and compact Markdown list envelopes are normalized once before the watcher resolves its project, identity, boards, tickets, or dedicated channel. Adding another model provider therefore reuses the same saved team connection and setup path instead of adding provider-specific project discovery. Optional actions such as ticket comments are used only when advertised; their absence cannot strand a completed ticket in a retry loop. The same zero-model check runs every 30 seconds as a safety net; a model starts only when pending work exists.
+Backend/BYO watchers reconcile once whenever the WebSocket starts or reconnects. A direct MCP session discovers and caches the backend's actual `tools/list` response, then uses available tools such as `list_agents`, `list_projects`, `list_tasks`, `list_task_types`, and `list_activity` to recover assigned tasks and recent mention activity missed while offline. Team discovery is shared by every runtime provider: structured MCP results and compact Markdown list envelopes are normalized once before the watcher resolves its project, identity, boards, tickets, or dedicated channel. Adding another model provider therefore reuses the same saved team connection and setup path instead of adding provider-specific project discovery. Optional actions such as ticket comments are used only when advertised; their absence cannot strand a completed ticket in a retry loop. After the recovery pass, the healthy event connection waits without polling MCP tools and starts a model only when work arrives.
 
 The backend MCP may be stateful or stateless. A successful initialize response without `Mcp-Session-Id` is accepted as stateless, so OpenCode agents do not stop with “MCP initialize returned no session id.” Each OpenCode lane keeps its MCP identity in a private per-agent config directory while the repository is supplied separately with `--dir`; stale workspace configuration therefore cannot swap one agent's credentials for another's. The generated remote configuration sends the agent headers directly, disables OAuth probing, and backend cycles never request relay-only inbox calls or MCP resource-discovery tools in place of team actions.
 
@@ -100,7 +102,7 @@ openvisio-agent stop --name ada                  # stop service + every ada watc
 
 Agents choose their tools, investigation steps, context management, and when to end a turn. Coding agents can delegate independent subtasks through the runtime’s native sub-agent tools: Codex multi-agent is enabled, OpenCode permits task delegation, and Claude permits Agent/Task. The parent supplies scoped context and file ownership, works alongside children, reviews their results, and reports once. Delegation depends on the tools advertised by the installed runtime; it does not grant additional task or publishing authority. Each turn receives the agent’s configured identity, role, and voice when supplied by its profile; that context is cached across restarts. Reply sessions can request their configured coding workspace through `openvisio_request_work_session`, carrying their findings, source thread, and permissions into the continuation. They do not ask you to reassign work because of an internal scheduling choice. A successful native final turn ends the cycle; it does not mark a ticket done. The agent decides when to update the board. Research, audits, and already-satisfied requests can finish without code changes, ticket mutations, or a PR. Tool failures stay visible as diagnostics without forcing another model turn or replacing the agent's explanation.
 
-The context graph records source-to-continuation relationships and recalls direct neighbors without walking into unrelated conversations. The watcher saves the agent's final response for delivery retry and avoids rerunning an unchanged assignment after restart. Claude, Codex, and OpenCode keep context within a ticket or conversation; native runtimes handle compaction. A stalled-session watchdog resets when activity arrives, so ongoing work is not stopped by a fixed task duration. Ownership, cancellation, delivery deduplication, credential injection, and repository permissions remain enforced.
+The context graph records source-to-continuation relationships and recalls direct neighbors without walking into unrelated conversations. The watcher saves the agent's final response for delivery retry and avoids rerunning an unchanged assignment after restart. Every supported runtime keeps context within a ticket or conversation; native runtimes handle compaction. A stalled-session watchdog resets when activity arrives, so ongoing work is not stopped by a fixed task duration. Ownership, cancellation, delivery deduplication, credential injection, and repository permissions remain enforced.
 
 The watcher can run up to three assigned coding tasks concurrently. Each ticket gets an isolated model runtime and ticket-specific worktree; tasks sharing the same mutable workspace remain serialized to prevent branch and file conflicts. Replies to one thread stay serialized while up to three independent threads run concurrently, and cancellation targets only the matching ticket or source thread. The work pool reuses local clones and is instructed to preserve dirty/staged work, create unique branches, and stage only task-owned changes. The independent reply lane receives a chat charter and no coding workspace. Codex publishes local branches through the constrained helper, then opens a PR with `gh pr create`; linked-codebase MCP operations are a fallback when the repository cannot be obtained locally.
 
@@ -112,7 +114,7 @@ Authorization recovery checks paused repositories locally every two seconds and
 
 Fresh top-level messages belong in the agent’s dedicated channel; responses to existing requests stay in their source thread. The watcher resolves a unique exact identity/name match (including `agent-alex` and `alex-agent`) and never falls back to general. Use `connect ... --channel <id>` for a differently named dedicated channel. If it is missing or ambiguous, ticket results remain recorded and channel delivery stays pending; the watcher does not invent a channel-creation tool.
 
-Codex and OpenCode use Mastra ACP directly. Work sessions are retained per ticket in a six-entry pool; reply sessions in an eight-entry pool. Idle sessions expire after five minutes and active sessions cannot be evicted. Git snapshots are asynchronous, lightweight commands lazily load the watcher, and logs separate queue wait, preflight, first-event, and total runtime time. Projects reconcile with concurrency three and enqueue tickets before reading optional activity history. Coordination sessions can update the board without gaining repository access.
+Codex, OpenCode, Gemini CLI, and Qwen Code use Mastra ACP directly. OpenCode starts only for an accepted cycle and exits as soon as that cycle releases it, so the idle watcher does not retain an OpenCode child process. Other runtimes retain work sessions per ticket in a six-entry pool and reply sessions in an eight-entry pool; their idle sessions expire after five minutes, and active sessions cannot be evicted. Git snapshots are asynchronous, lightweight commands lazily load the watcher, and logs separate queue wait, preflight, first-event, and total runtime time. Studio reads watcher liveness from the local PID lock instead of requiring journal heartbeats, and model changes arrive through filesystem notifications. Projects reconcile with concurrency three and enqueue tickets before reading optional activity history. Coordination sessions can update the board without gaining repository access.
 
 Assignments use independent FIFO entries with stable-key duplicate suppression and bounded, worktree-aware concurrency. Backlog recovery uses the same ticket verification path as WebSocket events, and each queued ticket is checked again before a model starts. MCP calls have a 20-second deadline including response bodies; tool discovery is cached and paginated. Codex MCP failures retain a bounded, credential-redacted reason in the watcher log. Cancellation targets only its ACP session. Credentials and replay state use atomic file replacement; Mastra persists contextual memory in libSQL.
 
@@ -134,7 +136,7 @@ Do not chase auto-changing watcher PIDs. `openvisio-agent stop --name <agent>` u
 ## Requirements
 
 - Node.js ≥ 22.13
-- Claude Code, Codex (`@openai/codex`), or OpenCode (the selected CLI is auto-installed if missing)
+- Claude Code, Codex (`@openai/codex`), OpenCode, Gemini CLI (`@google/gemini-cli`), or Qwen Code (`@qwen-code/qwen-code`). The selected CLI is installed when missing.
 
 ## Getting a setup code
 

package/USER_GUIDE.md

@@ -14,7 +14,7 @@ The first semantic search downloads a local embedding model. Keyword search rema
 
 ## Before you begin
 
-You need Node.js **22.13 or newer**, access to your OpenVisio team, and a supported coding agent: Claude Code, Codex, or OpenCode. Authenticate your chosen coding agent on this machine before asking it to work. Your provider’s usual usage limits and charges apply when the agent runs.
+You need Node.js **22.13 or newer**, access to your OpenVisio team, and a supported coding agent: Claude Code, Codex, OpenCode, Gemini CLI, or Qwen Code. Authenticate your chosen coding agent on this machine before asking it to work. Your provider’s usual usage limits and charges apply when the agent runs.
 
 Check your installed versions in a terminal:
 

package/bin/cli.mjs

@@ -15,6 +15,7 @@ import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
 import { parseFlags, slugify, stripSlash, exchangeToken, ensureClaude, ensureCodex, writeJson, mcpConfigPath, configPath, chmodSafe, onPath, OV_DIR, DEFAULT_WORKSPACE, fail, ok, info } from '../src/lib.mjs'
 import { authorizePrPush, pushPrBranch, revokePrPush, configurePrPublishing } from '../src/pr-push.mjs'
+import { runtimeProvider, supportedRuntimeList } from '../src/runtime-providers.mjs'
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const VERSION = (() => { try { return JSON.parse(readFileSync(join(HERE, '..', 'package.json'), 'utf8')).version } catch { return '0.0.0' } })()
@@ -24,8 +25,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>] [--agent claude|codex|opencode]
-  openvisio-agent connect --backend <url> --key <api-key> --id <identifier> [--name "<agent>"] [--ws <wss-url>] [--mcp-url <url>] [--agent claude|codex|opencode]
+  openvisio-agent connect <ovs_code> --host <url> [--name "<agent>"] [--mcp-url <url>] [--agent ${supportedRuntimeList('|')}]
+  openvisio-agent connect --backend <url> --key <api-key> --id <identifier> [--name "<agent>"] [--ws <wss-url>] [--mcp-url <url>] [--agent ${supportedRuntimeList('|')}]
   openvisio-agent watch   --name <agent> [--install] [--workspace <dir>] [--chat-only] [--model <m>] [--chat-model <m>] [--debug]
   openvisio-agent stop    --name <agent>
   openvisio-agent studio  [--port <number>] [--no-open] [--demo]
@@ -55,12 +56,12 @@ 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>   coding-agent runtime: claude (default), codex, or opencode.
-                     Codex authenticates separately with \`codex login\`; opencode
-                     authenticates with \`opencode auth login\`.
+    --agent <name>   coding-agent runtime: ${supportedRuntimeList(', ')}.
+                     The selected CLI is installed when missing. Authenticate it
+                     once with its normal login flow before the watcher runs.
     --chat-only      disable code work — chat/ticket tools only.
     --model <m>      coding model. Claude defaults to sonnet; Codex defaults to
-                     gpt-5.6-sol; OpenCode uses its configured default.
+                     gpt-5.6-sol; other providers use their configured default.
                      Engineers can also change it live from chat: "@agent /model …".
     --chat-model <m> coordination model for chat, triage, and board movement.
                      Claude defaults to haiku. Codex uses gpt-5.6-sol for every
@@ -135,19 +136,26 @@ function ensureAgentInstalled() {
 // 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 !== 'codex' && a !== 'opencode') fail(`Unknown --agent "${a}". Supported runtimes: claude | codex | opencode.`)
+  if (!runtimeProvider(a)) fail(`Unknown --agent "${a}". Supported runtimes: ${supportedRuntimeList()}.`)
   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')
+function ensureRuntime(agent) {
+  if (agent === 'claude') return ensureClaude()
+  if (agent === 'codex') return ensureCodex()
+  const provider = runtimeProvider(agent)
+  if (onPath(provider.command)) return provider.command
+  info(`${provider.name} not found on PATH — installing ${provider.npmPackage} globally…`)
+  spawnSync('npm', ['i', '-g', provider.npmPackage], { stdio: 'inherit', shell: process.platform === 'win32' })
+  if (!onPath(provider.command)) fail(`${provider.name} still isn't on PATH after install. Install ${provider.npmPackage}, run \`${provider.authCommand}\` once, and re-run.`)
+  info(`Installed ${provider.name}. Authenticate it once if you haven't:  ${provider.authCommand}`)
+  return onPath(provider.command)
+}
+
+function runtimeReadyMessage(agent) {
+  const provider = runtimeProvider(agent)
+  if (agent === 'claude') return 'Claude Code now has the openvisio-team tools. Run /mcp in Claude Code to confirm.'
+  return `Runtime: ${provider.name}. The watcher injects the authenticated openvisio-team MCP into every ACP session. Authenticate once with \`${provider.authCommand}\`.`
 }
 
 async function runConnect({ positional, flags }) {
@@ -174,10 +182,8 @@ async function runConnect({ positional, flags }) {
     // 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 if (agent === 'codex') {
-    ensureCodex()
   } else {
-    ensureOpencode() // the watcher writes opencode.json with the remote MCP at runtime
+    ensureRuntime(agent)
   }
   const wsWorkdir = flags.workdir === true ? process.cwd() : flags.workdir ? String(flags.workdir) : flags.workspace ? String(flags.workspace) : ''
   if (!flags['chat-only']) configurePrPublishing({ workspace: wsWorkdir || DEFAULT_WORKSPACE, enabled: !flags['no-pr-push'] })
@@ -185,11 +191,7 @@ async function runConnect({ positional, flags }) {
 
   ok(`Connected "${name}" to ${host}.`)
   info()
-  info(agent === 'opencode'
-    ? 'Runtime: opencode. The watcher writes an opencode.json with the openvisio-team tools; make sure opencode is authenticated (opencode auth login).'
-    : agent === 'codex'
-      ? 'Runtime: Codex. The watcher injects only the openvisio-team MCP into each cycle; authenticate once with `codex login`.'
-      : 'Claude Code now has the openvisio-team tools. Run  /mcp  in Claude Code to confirm.')
+  info(runtimeReadyMessage(agent))
   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):')
@@ -229,6 +231,7 @@ async function runConnectBackend({ flags }) {
   const name = (flags.name && String(flags.name)) || 'backend-agent'
   const slug = slugify(name)
   const agent = agentFlag(flags)
+  ensureRuntime(agent)
 
   // 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.
@@ -253,10 +256,6 @@ async function runConnectBackend({ flags }) {
       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 if (agent === 'codex') {
-      ensureCodex()
-    } else {
-      ensureOpencode() // the watcher writes opencode.json with the remote MCP at runtime
     }
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openvisio-agent",
-  "version": "0.25.4",
-  "description": "Connect Claude Code, Codex, or OpenCode to an OpenVisio team \u2014 MCP tools + optional autonomy \u2014 in one command.",
+  "version": "0.25.6",
+  "description": "Connect Claude Code, Codex, OpenCode, Gemini CLI, or Qwen Code to an OpenVisio team \u2014 MCP tools + optional autonomy \u2014 in one command.",
   "type": "module",
   "bin": {
     "openvisio-agent": "bin/cli.mjs"
@@ -30,6 +30,8 @@
     "claude",
     "claude-code",
     "codex",
+    "gemini-cli",
+    "qwen-code",
     "agent",
     "autonomy"
   ],

package/scenarios/runtime.scenarios.mjs

@@ -215,9 +215,11 @@ for (const phase of ['eviction', 'close']) for (const failureKind of ['sync', 'a
 }
 for (const [name, options] of [
   ['zero-capacity', { capacity: 0 }], ['negative-capacity', { capacity: -1 }], ['fractional-capacity', { capacity: 1.5 }],
-  ['infinite-capacity', { capacity: Infinity }], ['zero-expiry', { idleMs: 0 }], ['negative-expiry', { idleMs: -1 }],
-  ['infinite-expiry', { idleMs: Infinity }], ['nan-expiry', { idleMs: NaN }],
+  ['infinite-capacity', { capacity: Infinity }],
 ]) add(`pool-invalid-${name}`, 'runtime-pool', `Invalid ${name} configuration fails before starting any timer`, async () => { assert.throws(() => createRunnerPool({ ...options, create: () => ({}) }), /positive/) })
+for (const [name, idleMs] of [['negative-expiry', -1], ['infinite-expiry', Infinity], ['nan-expiry', NaN]]) {
+  add(`pool-invalid-${name}`, 'runtime-pool', `Invalid ${name} configuration fails before starting any timer`, async () => { assert.throws(() => createRunnerPool({ idleMs, create: () => ({}) }), /non-negative/) })
+}
 
 function fakeAcp({ events = [], negotiate, select, stream, cancel } = {}) {
   const state = { instances: [], prompts: [], modelReads: 0, modelSets: [], disconnects: 0, cancels: 0 }

package/scripts/certify.mjs

@@ -24,6 +24,7 @@ run('diff whitespace check', 'git', ['diff', '--check'], repo)
 const watcher = readFileSync(join(root, 'src', 'watch.mjs'), 'utf8')
 const events = readFileSync(join(root, 'src', 'events.mjs'), 'utf8')
 const memory = readFileSync(join(root, 'src', 'memory.mjs'), 'utf8')
+const journal = readFileSync(join(root, 'src', 'agent-journal.mjs'), 'utf8')
 const mcpHttp = readFileSync(join(root, 'src', 'mcp-http.mjs'), 'utf8')
 const opencodeConfig = readFileSync(join(root, 'src', 'opencode-config.mjs'), 'utf8')
 const codexConfig = readFileSync(join(root, 'src', 'codex-config.mjs'), 'utf8')
@@ -33,6 +34,7 @@ const cli = readFileSync(join(root, 'bin', 'cli.mjs'), 'utf8')
 const websocket = readFileSync(join(root, 'src', 'ws.mjs'), 'utf8')
 const cycleQueue = readFileSync(join(root, 'src', 'cycle-queue.mjs'), 'utf8')
 const mastraHarness = readFileSync(join(root, 'src', 'mastra-harness.mjs'), 'utf8')
+const runtimeProviders = readFileSync(join(root, 'src', 'runtime-providers.mjs'), 'utf8')
 const modelSelection = readFileSync(join(root, 'src', 'model-selection.mjs'), 'utf8')
 const activityHook = readFileSync(join(repo, 'frontend', 'hooks', 'useAgentActivity.ts'), 'utf8')
 const taskHook = readFileSync(join(repo, 'frontend', 'hooks', 'useBackendTasks.ts'), 'utf8')
@@ -49,6 +51,9 @@ const assertions = [
   ['authorization recovery is local and independent of backlog cadence', watcher.includes('resumeReadyAuthorizations(), 2_000') && watcher.includes('releaseAuthorizedPause(key')],
   ['new follow-ups only deduplicate later replies', watcher.includes('repliesAfterSource(renderedAgentMessages') && watcher.includes('sourceMessageId: mid')],
   ['Mastra snapshots do not block the event loop', mastraHarness.includes('await execFileAsync') && !mastraHarness.includes('spawnSync')],
+  ['OpenCode exits after work while the event watcher stays idle', runtimeProviders.includes("id: 'opencode'") && runtimeProviders.includes('idleSessionMs: 0') && watcher.includes('idleMs: runtimeIdleMs')],
+  ['healthy backend watchers do not poll projects while idle', watcher.includes('onConnect: () =>') && watcher.includes('void reconcileBacklog()') && !watcher.includes('taskProbeTimer') && !watcher.includes('taskProbeStartTimer')],
+  ['idle watchers use event notifications without journal or settings polling', watcher.includes('watchFs(stateDir') && !watcher.includes('modelSettingsTimer') && !journal.includes("emit('runtime.heartbeat'")],
   ['ticket pickup precedes optional activity reads', watcher.indexOf("await handleTaskSignal('task:assigned'", watcher.indexOf('const reconcileBacklog')) < watcher.indexOf("const activityData = await callMcpTool", watcher.indexOf('const reconcileBacklog'))],
   ['task:assigned is handled', watcher.includes("k === 'task:assigned'")],
   ['task signals are verified with get_ticket', watcher.includes("callMcpTool('get_ticket'")],
@@ -85,7 +90,7 @@ const assertions = [
   ['reply runner has no coding workspace or coding charter', watcher.includes("workdir: ''") && watcher.includes("systemPrompt: CHAT_CHARTER + '\\n\\n' + credNote") && opencodeConfig.includes("'*': 'deny'")],
   ['MCP requests have a deadline including response bodies', mcpHttp.includes('controller.abort()') && mcpHttp.includes('res.text()')],
   ['Mastra memory uses real ticket and thread identities', watcher.includes('createMastraMemory') && watcher.includes('await memory.context(memoryRefs)') && memory.includes('new Memory({ storage') && memory.includes('new LibSQLStore') && memory.includes('ticket:${refs.projectId}:${refs.ticketId}') && memory.includes('channel:${refs.channelId}:thread:')],
-  ['Codex and OpenCode use warm scoped Mastra ACP sessions', watcher.includes('createMastraAcpRunner') && watcher.includes('workRunners.acquire(sessionKey') && watcher.includes('replyRunners.acquire(key') && mastraHarness.includes('persistSession: true')],
+  ['ACP providers use scoped Mastra sessions', watcher.includes('createMastraAcpRunner') && watcher.includes('workRunners.acquire(sessionKey') && watcher.includes('replyRunners.acquire(key') && mastraHarness.includes('persistSession: true')],
   ['runtime models are selected explicitly before work starts', mastraHarness.includes('getAvailableModels()') && mastraHarness.includes('resolveAvailableModel(requestedModel') && mastraHarness.includes('acp.setModel(resolution.selected)') && modelSelection.includes('automatic model substitution is disabled') && watcher.includes('if (changed) persistModel()')],
   ['one watcher owns bounded work and per-thread reply sessions', watcher.includes('MAX_CONCURRENT_WORKERS = 3') && watcher.includes('workRunners.release(sessionKey)') && watcher.includes('replyRunners.release(key)') && watcher.includes('groupKey: (item) => item.taskRef')],
   ['workers serialize shared worktrees while independent worktrees run concurrently', watcher.includes('groupKey: (item) => item.workdir || workdir') && cycleQueue.includes('active.size < concurrency') && cycleQueue.includes('activeGroups.has(candidate[1].group)')],

package/src/agent-journal.mjs

@@ -59,7 +59,7 @@ export function createAgentJournal({ stateDir, agent, secrets = [] }) {
   const stem = `${slug}-${digest}`
   const path = join(directory, stem + '.jsonl')
   let sequence = 0, pendingBytes = 0, dropped = 0, written = 0, lastError = null
-  let timer, heartbeat, closing = false, closePromise, writing = false
+  let timer, closing = false, closePromise, writing = false
   const pending = []
   const ready = (async () => {
     await mkdir(directory, { recursive: true, mode: 0o700 })
@@ -120,11 +120,8 @@ export function createAgentJournal({ stateDir, agent, secrets = [] }) {
     catch (error) { lastError = error; return false }
   }
   emit('runtime.started', { status: 'running' })
-  heartbeat = setInterval(() => emit('runtime.heartbeat', { status: 'running', droppedEvents: dropped }), 15_000)
-  heartbeat.unref?.()
   const close = () => {
     if (closePromise) return closePromise
-    clearInterval(heartbeat)
     emit('runtime.stopped', { status: 'stopped', droppedEvents: dropped })
     closing = true
     closePromise = (async () => {

package/src/agent-removal.mjs

@@ -8,6 +8,7 @@ import { join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { OV_DIR, slugify } from './lib.mjs'
 import { agentProcessSnapshot, agentProcessTree, stopAgentProcessTree } from './agent-processes.mjs'
+import { RUNTIME_IDS } from './runtime-providers.mjs'
 
 const exec = promisify(execFile)
 const hash = value => createHash('sha256').update(value).digest('hex')
@@ -63,7 +64,7 @@ export async function planAgentRemoval({ stateDir, slug }) {
   for (const name of names) if (await lstat(join(stateDir, name)).catch(() => null)) files.push(name)
   if (await realDirectory(join(stateDir, 'observability'))) {
     // The stem contains this setup's slug and the exact provider/identity hash.
-    const stems = [...new Set(['claude', 'codex', 'opencode', config.agent || 'claude'])].map(provider => `${slug.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 60)}-${hash(`${identifier}:${provider}`).slice(0, 12)}`)
+    const stems = [...new Set([...RUNTIME_IDS, config.agent || 'claude'])].map(provider => `${slug.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 60)}-${hash(`${identifier}:${provider}`).slice(0, 12)}`)
     for (const name of await readdir(join(stateDir, 'observability'))) {
       if (stems.some(stem => [`${stem}.jsonl`, `${stem}.1.jsonl`, `${stem}.2.jsonl`].includes(name))) files.push(`observability/${name}`)
     }

package/src/mastra-harness.mjs

@@ -2,7 +2,6 @@ import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
 import { fileURLToPath } from 'node:url'
 import { AcpAgent } from '@mastra/acp'
-import { onPath } from './lib.mjs'
 import { resolveAvailableModel } from './model-selection.mjs'
 import { codexPolicyBlock } from './events.mjs'
 import { WORK_SESSION_TOOL, workSessionRequest } from './runtime-control.mjs'
@@ -10,6 +9,7 @@ import { contextToolNames } from './context-tools.mjs'
 import { buildOpencodeConfig } from './opencode-config.mjs'
 import { opencodeProviderFailure } from './opencode-failure.mjs'
 import { isTransportInterruption } from './transport-recovery.mjs'
+import { acpRuntimeCommand } from './runtime-providers.mjs'
 
 const MCP_TOOL_NAMES = [
   WORK_SESSION_TOOL, ...contextToolNames, 'list_agents', 'list_projects', 'list_boards', 'list_tasks', 'list_task_types', 'get_ticket',
@@ -34,17 +34,8 @@ async function abortable(operation, signal) {
   finally { signal.removeEventListener('abort', onAbort) }
 }
 
-function commandFor(agent) {
-  if (agent === 'opencode') return { command: onPath('opencode') || 'opencode', args: ['acp', '--print-logs', '--log-level', 'ERROR'] }
-  if (agent === 'codex') {
-    const filename = process.platform === 'win32' ? 'codex-acp.cmd' : 'codex-acp'
-    return { command: fileURLToPath(new URL(`../node_modules/.bin/${filename}`, import.meta.url)), args: [] }
-  }
-  return null
-}
-
 export async function listAcpRuntimeModels(agent, { AcpAgentClass = AcpAgent, cwd = process.cwd(), timeoutMs = 15_000 } = {}) {
-  const runtime = commandFor(agent)
+  const runtime = acpRuntimeCommand(agent)
   if (!runtime) return []
   const acp = new AcpAgentClass({
     id: `openvisio-${agent}-model-catalog-${Date.now()}`,
@@ -127,7 +118,7 @@ export function createMastraAcpRunner({
   agent, mcpUrl, mcpHeaders = {}, workdir, canCode = !!workdir, canCoordinate = false, workspaceAvailable = canCode, maxCycleMs = 20 * 60_000,
   log = () => {}, debug = false, model, onTool, onEvent, systemPrompt = '', getContextEnvironment, AcpAgentClass = AcpAgent,
 }) {
-  const runtime = commandFor(agent)
+  const runtime = acpRuntimeCommand(agent)
   if (!runtime) return null
   if (!Number.isFinite(maxCycleMs) || maxCycleMs <= 0 || maxCycleMs > 2_147_483_647) throw new Error('ACP maxCycleMs must be a positive supported timeout')
   let active = null

package/src/model-settings.mjs

@@ -4,6 +4,7 @@ import { join } from 'node:path'
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
 import { onPath } from './lib.mjs'
+import { runtimeProvider } from './runtime-providers.mjs'
 
 const modelId = value => typeof value === 'string' && value.length <= 200 && /^[a-zA-Z0-9][a-zA-Z0-9_.:/+\[\]-]*$/.test(value)
 const problem = (message, status = 400) => Object.assign(new Error(message), { status })
@@ -47,6 +48,8 @@ export function saveModelSettings(stateDir, slug, input) {
 }
 
 export async function listRuntimeModels(provider) {
+  const runtime = runtimeProvider(provider)
+  if (!runtime) return []
   if (provider === 'claude') return ['sonnet', 'opus', 'haiku']
   if (provider === 'codex') {
     try {
@@ -56,9 +59,19 @@ export async function listRuntimeModels(provider) {
     } catch { /* keep the configured watcher default available when ACP discovery is unavailable */ }
     return ['gpt-5.6-sol[medium]']
   }
-  if (provider !== 'opencode') return []
-  const command = onPath('opencode')
-  if (!command) throw problem('OpenCode is not installed on this computer.', 503)
-  const { stdout } = await promisify(execFile)(command, ['models'], { timeout: 15_000, maxBuffer: 1024 * 1024, encoding: 'utf8' })
-  return [...new Set(stdout.split(/\r?\n/).map(s => s.trim()).filter(modelId))].slice(0, 1000)
+  if (provider === 'opencode') {
+    const command = onPath('opencode')
+    if (!command) throw problem('OpenCode is not installed on this computer.', 503)
+    const { stdout } = await promisify(execFile)(command, ['models'], { timeout: 15_000, maxBuffer: 1024 * 1024, encoding: 'utf8' })
+    return [...new Set(stdout.split(/\r?\n/).map(s => s.trim()).filter(modelId))].slice(0, 1000)
+  }
+  try {
+    const { listAcpRuntimeModels } = await import('./mastra-harness.mjs')
+    const models = (await listAcpRuntimeModels(provider)).filter(modelId)
+    if (models.length) return models.slice(0, 1000)
+  } catch (error) {
+    if (!onPath(runtime.command)) throw problem(`${runtime.name} is not installed on this computer.`, 503)
+    throw error
+  }
+  return []
 }

package/src/runner-pool.mjs

@@ -2,7 +2,7 @@
 // session, and never share history between tickets or conversation threads.
 export function createRunnerPool({ create, capacity = 8, idleMs = 300_000, now = Date.now, onError = () => {} }) {
   if (!Number.isInteger(capacity) || capacity < 1) throw new Error('runner pool capacity must be a positive integer')
-  if (!Number.isFinite(idleMs) || idleMs <= 0) throw new Error('runner pool idleMs must be positive and finite')
+  if (!Number.isFinite(idleMs) || idleMs < 0) throw new Error('runner pool idleMs must be non-negative and finite')
   const entries = new Map()
   let closed = false
   const report = (error) => { try { Promise.resolve(onError(error)).catch(() => {}) } catch { /* reporting cannot strand cleanup */ } }
@@ -11,14 +11,14 @@ export function createRunnerPool({ create, capacity = 8, idleMs = 300_000, now =
   }
   function prune() {
     for (const [key, entry] of entries) {
-      if (!entry.busy && (now() - entry.usedAt >= idleMs || entries.size > capacity)) {
+      if (!entry.busy && (idleMs === 0 || now() - entry.usedAt >= idleMs || entries.size > capacity)) {
         entries.delete(key)
         dispose(entry)
       }
     }
   }
-  const timer = setInterval(prune, Math.min(idleMs, 30_000))
-  timer.unref?.()
+  const timer = idleMs === 0 ? null : setInterval(prune, Math.min(idleMs, 30_000))
+  timer?.unref?.()
   return {
     acquire(key, options) {
       if (closed) throw new Error('Session pool is closed')
@@ -40,7 +40,7 @@ export function createRunnerPool({ create, capacity = 8, idleMs = 300_000, now =
     close() {
       if (closed) return
       closed = true
-      clearInterval(timer)
+      if (timer) clearInterval(timer)
       const closing = [...entries.values()]
       entries.clear()
       for (const entry of closing) dispose(entry)

package/src/runtime-providers.mjs

@@ -0,0 +1,46 @@
+import { fileURLToPath } from 'node:url'
+import { onPath } from './lib.mjs'
+
+const providers = {
+  claude: {
+    id: 'claude', name: 'Claude Code', kind: 'native', command: 'claude', npmPackage: '@anthropic-ai/claude-code',
+    authCommand: 'claude', defaultModel: 'sonnet', defaultChatModel: 'haiku', idleSessionMs: 300_000,
+  },
+  codex: {
+    id: 'codex', name: 'Codex', kind: 'acp', command: 'codex', npmPackage: '@openai/codex',
+    authCommand: 'codex login', defaultModel: 'gpt-5.6-sol[medium]', defaultChatModel: 'gpt-5.6-sol[medium]', idleSessionMs: 300_000,
+  },
+  opencode: {
+    id: 'opencode', name: 'OpenCode', kind: 'acp', command: 'opencode', npmPackage: 'opencode-ai',
+    authCommand: 'opencode auth login', defaultModel: '', defaultChatModel: '', idleSessionMs: 0, acpArgs: ['acp', '--print-logs', '--log-level', 'ERROR'],
+  },
+  gemini: {
+    id: 'gemini', name: 'Gemini CLI', kind: 'acp', command: 'gemini', npmPackage: '@google/gemini-cli',
+    authCommand: 'gemini', defaultModel: '', defaultChatModel: '', idleSessionMs: 300_000, acpArgs: ['--acp'],
+  },
+  qwen: {
+    id: 'qwen', name: 'Qwen Code', kind: 'acp', command: 'qwen', npmPackage: '@qwen-code/qwen-code',
+    authCommand: 'qwen', defaultModel: '', defaultChatModel: '', idleSessionMs: 300_000, acpArgs: ['--acp'],
+  },
+}
+
+export const RUNTIME_IDS = Object.freeze(Object.keys(providers))
+export const ACP_RUNTIME_IDS = Object.freeze(RUNTIME_IDS.filter(id => providers[id].kind === 'acp'))
+
+export function runtimeProvider(id) {
+  return providers[String(id || '').toLowerCase()] || null
+}
+
+export function supportedRuntimeList(separator = ' | ') {
+  return RUNTIME_IDS.join(separator)
+}
+
+export function acpRuntimeCommand(id) {
+  const provider = runtimeProvider(id)
+  if (!provider || provider.kind !== 'acp') return null
+  if (provider.id === 'codex') {
+    const filename = process.platform === 'win32' ? 'codex-acp.cmd' : 'codex-acp'
+    return { command: fileURLToPath(new URL(`../node_modules/.bin/${filename}`, import.meta.url)), args: [] }
+  }
+  return { command: onPath(provider.command) || provider.command, args: [...(provider.acpArgs || [])] }
+}

package/src/studio-server.mjs

@@ -112,8 +112,13 @@ export async function readStudioSnapshot({ stateDir, now = Date.now, journalCach
   const agentsById = new Map(configured.map((agent) => [agent.identifier, agent]))
   for (const event of latest.values()) {
     const age = now() - Date.parse(event.timestamp)
-    const online = age >= -5000 && age <= FRESH_MS && event.type !== 'runtime.stopped' && pidAlive(event.pid)
     const existing = agentsById.get(event.agent.identifier)
+    // Configured watchers own a PID lock, so Studio can report their real process
+    // state without forcing an idle process to append heartbeat records forever.
+    // Freshness remains a compatibility fallback for older, unconfigured journals.
+    const configuredAlive = existing?.watcherAlive === true && existing.pid === event.pid
+    const recentUnconfigured = !existing?.configured && age >= -5000 && age <= FRESH_MS && pidAlive(event.pid)
+    const online = event.type !== 'runtime.stopped' && (configuredAlive || recentUnconfigured)
     agentsById.set(event.agent.identifier, { ...existing, id: event.agent.identifier, identifier: event.agent.identifier, slug: existing?.slug || event.agent.slug || event.agent.identifier, name: existing?.name || event.agent.slug || event.agent.identifier, provider: event.agent.provider || 'unknown', runId: event.runId, pid: Number.isSafeInteger(event.pid) ? event.pid : null, watcherAlive: online, status: online ? 'online' : 'offline', lastSeen: event.timestamp, lastEventType: event.type })
   }
   const agents = [...agentsById.values()]

package/src/watch.mjs

@@ -1,12 +1,10 @@
-// The OpenVisio autonomy watcher — an event-driven "warm" loop. Cheaply polls
-// /api/agent/inbox (no model) and pokes ONE persistent Claude Code stream-json
-// session with a cycle per new @mention / follow-up / ticket. Ported verbatim from
-// the shell installer so behaviour is identical — now shipped in the package rather
-// than written to disk from a pasted heredoc.
+// The OpenVisio autonomy watcher — an event-driven loop. It waits on the team
+// event connection and starts a runtime only for accepted work. Relay mode keeps
+// compatibility with older inbox polling connections.
 
 import { spawn, spawnSync } from 'node:child_process'
 import { AsyncLocalStorage } from 'node:async_hooks'
-import { closeSync, writeFileSync, mkdirSync, mkdtempSync, rmSync, existsSync, openSync, readFileSync, readdirSync, unlinkSync } from 'node:fs'
+import { closeSync, writeFileSync, mkdirSync, mkdtempSync, rmSync, existsSync, openSync, readFileSync, readdirSync, unlinkSync, watch as watchFs } from 'node:fs'
 import { homedir, tmpdir } from 'node:os'
 import { fileURLToPath } from 'node:url'
 import { join, dirname } from 'node:path'
@@ -37,6 +35,7 @@ import { createAgentJournal } from './agent-journal.mjs'
 import { readModelSettings } from './model-settings.mjs'
 import { startStudioInBackground } from './studio-cli.mjs'
 import { toolData } from './team-data.mjs'
+import { runtimeProvider, supportedRuntimeList } from './runtime-providers.mjs'
 
 function runtimeJournal(options, supplied) {
   let journal
@@ -267,10 +266,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),
-  // Codex (`codex exec`), or opencode (`opencode run`). Default claude.
+  // Which coding-agent runtime drives the cycles. Claude keeps its native stream;
+  // ACP-capable runtimes share the Mastra harness. Default claude.
   const agent = String(flags.agent || flags.runtime || (saved && saved.agent) || 'claude').toLowerCase()
-  if (agent !== 'claude' && agent !== 'codex' && agent !== 'opencode') fail(`Unknown --agent "${agent}". Supported runtimes: claude | codex | opencode.`)
+  const provider = runtimeProvider(agent)
+  if (!provider) fail(`Unknown --agent "${agent}". Supported runtimes: ${supportedRuntimeList()}.`)
   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
@@ -286,9 +286,9 @@ export async function runWatch({ flags }) {
   if (workdir) configurePrPublishing({ workspace: workdir, enabled: !flags['no-pr-push'] && saved?.prPublishing !== false })
   if (workdir) { try { mkdirSync(workdir, { recursive: true }) } catch { /* best-effort; spawn will surface a real problem */ } }
 
-  // Use a specific Codex ID; configured chat and code tiers remain independent.
-  const defaultModel = agent === 'claude' ? 'sonnet' : agent === 'codex' ? 'gpt-5.6-sol[medium]' : ''
-  const defaultChatModel = agent === 'claude' ? 'haiku' : agent === 'codex' ? 'gpt-5.6-sol[medium]' : ''
+  // Configured chat and code tiers remain independent for every runtime.
+  const defaultModel = provider.defaultModel
+  const defaultChatModel = provider.defaultChatModel
   const model = String(flags.model || (saved && saved.model) || defaultModel)
   const chatModel = String(flags['chat-model'] || (saved && saved.chatModel) || defaultChatModel)
 
@@ -338,11 +338,11 @@ export async function runWatch({ flags }) {
   return loop({ host, key, slug: slug || 'openvisio', claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug: !!flags.debug })
 }
 
-// Claude keeps its native stream; Codex and OpenCode use Mastra ACP.
+// Claude keeps its native stream; every ACP provider uses the same Mastra harness.
 export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model, onTool, onEvent, systemPrompt, getContextEnvironment, canCoordinate = false, workspaceAvailable = !!workdir }) {
   const canCode = !!workdir
   const maxCycleMs = canCode ? MAX_CODE_CYCLE_MS : MAX_CYCLE_MS
-  // Codex and OpenCode run through Mastra's ACP harness. Each queue worker gets
+  // ACP providers run through Mastra's shared harness. Each queue worker gets
   // its own ACP session and worktree, so cancellation, permissions and context
   // cannot bleed across concurrently assigned tickets.
   const mastraRunner = createMastraAcpRunner({ agent, mcpUrl, mcpHeaders, workdir, canCode, canCoordinate, workspaceAvailable, maxCycleMs, log, debug, model, onTool, onEvent, systemPrompt, getContextEnvironment })
@@ -583,8 +583,8 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
 
 // ── the backend WS loop ──────────────────────────────────────────────────────
 // One WebSocket identity feeds independent serialized work/reply queues. Each
-// accepted source keeps its own context; direct MCP reconciliation recovers work
-// without model spend while idle.
+// accepted source keeps its own context; direct MCP reconciliation runs once
+// when the event connection starts or reconnects, then the watcher stays idle.
 function loopBackendWs(options) {
   const watcher = createBackendWatcher(options)
   const stop = () => void watcher.close().then(() => process.exit(0))
@@ -656,6 +656,10 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   // runtimes. Replies serialize within a thread while independent threads run
   // concurrently behind the same delivery guards.
   const MAX_CONCURRENT_WORKERS = 3
+  // OpenCode's ACP child consumes meaningful CPU and memory even between prompts.
+  // Keep the event watcher cheap by disposing it as soon as a cycle releases the
+  // runner. Other providers retain their configured warm-session window.
+  const runtimeIdleMs = runtimeProvider(agent)?.idleSessionMs ?? 300_000
   const activeWorkRunners = new Set()
   const recoveryWaiters = new Set()
   const recoveryDelays = dependencies.transportRecoveryDelays || transportRecoveryDelays
@@ -668,10 +672,12 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   const workRunners = createRunnerPool({
     create: ({ control, workdir }) => createWorkRunner(control, workdir),
     capacity: 6,
+    idleMs: runtimeIdleMs,
   })
   const activeReplyRunners = new Set()
   const replyRunners = createRunnerPool({
     capacity: 8,
+    idleMs: runtimeIdleMs,
     create: ({ key, canCoordinate }) => makeRunner({
       ...runnerOptions, workdir: '', canCoordinate,
       systemPrompt: CHAT_CHARTER + '\n\n' + credNote,
@@ -2185,19 +2191,16 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   deliveryTimer?.unref?.()
   const authorizationTimer = autoStart ? setInterval(() => void resumeReadyAuthorizations(), 2_000) : null
   authorizationTimer?.unref?.()
-  const modelSettingsTimer = autoStart ? setInterval(refreshModelSettings, 2_000) : null
-  modelSettingsTimer?.unref?.()
+  let modelSettingsWatcher = null
+  if (autoStart) {
+    try {
+      modelSettingsWatcher = watchFs(stateDir, { persistent: false }, (_event, filename) => {
+        if (!filename || String(filename) === `${slug}.json`) refreshModelSettings()
+      })
+    } catch { /* every cycle still refreshes settings before choosing a model */ }
+  }
   emit('models.updated', { model: codeModel, chatModel: liteModel, modelSettingsRevision })
-  const heartbeatTimer = autoStart ? setInterval(() => {
-    emit('watcher.heartbeat', { status: 'running', active: queues.work.activeSize + queues.reply.activeSize, pending: queues.work.size + queues.reply.size, model: codeModel, chatModel: liteModel, modelSettingsRevision, workdir: workdir || '', ...(agentAppearance ? { profile: agentAppearance } : {}) })
-    // The Studio reads a bounded journal tail. Re-state current queue ownership
-    // so a long-running cycle stays visible after its start event rotates out.
-    for (const { data, control } of liveCycles.values()) {
-      if (!control.cancelled) emit('cycle.snapshot', { ...data, status: control.outcome, attempt: control.attempt || 1 })
-    }
-  }, 15_000) : null
-  heartbeatTimer?.unref?.()
-  let introTimer = null, taskProbeStartTimer = null, taskProbeTimer = null
+  let introTimer = null
   if (autoStart && (mcpConfig || mcpUrl)) {
     // Workspace ethics: a one-time hello the FIRST time this agent ever connects.
     const introMarker = join(stateDir, 'intro-' + slugify(identifier) + '.done')
@@ -2210,13 +2213,8 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         }).catch((e) => log('guarded introduction failed: ' + (e?.message || e)))
       }, 5000) // let the socket subscribe first
     }
-    // Reconciliation replaces the old model-driven startup/daily sweep. It uses
-    // supported MCP tools directly, stays silent when empty, and hands verified
-    // coding tasks to the full lane instead of letting Luna announce it cannot code.
-    taskProbeStartTimer = setTimeout(() => void reconcileBacklog(), 3_000)
-    // WebSocket delivery is primary. A short bounded reconciliation interval
-    // keeps mentions responsive when a deployment omits targeted dispatch.
-    taskProbeTimer = setInterval(() => void reconcileBacklog(), 30_000)
+    // The WebSocket onConnect hook performs one recovery pass. Do not poll the
+    // backend while a healthy event connection is already waiting for work.
   } else {
     log('no MCP config — skipping intro + daily sweep (agent has no tools to post/act)')
   }
@@ -2230,11 +2228,8 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     closePromise = (async () => {
       clearInterval(authorizationTimer)
       clearInterval(deliveryTimer)
-      clearInterval(heartbeatTimer)
-      clearInterval(modelSettingsTimer)
+      modelSettingsWatcher?.close()
       if (introTimer) clearTimeout(introTimer)
-      if (taskProbeStartTimer) clearTimeout(taskProbeStartTimer)
-      if (taskProbeTimer) clearInterval(taskProbeTimer)
       try { handle?.close() } catch { /* already disconnected */ }
       for (const queue of Object.values(queues)) {
         queue.cancel(() => true, (item) => { item.control.cancelled = true; item.control.wakeRecovery?.() })
@@ -2297,12 +2292,9 @@ function loop({ host, key, slug, claude, agent, mcpConfig, mcpUrl, workdir, mode
 
   const seen = new Set()
   let busy = false
-  const heartbeatTimer = setInterval(() => emit('watcher.heartbeat', { status: 'running', active: busy ? 1 : 0, model, chatModel, workdir: workdir || '' }), 15_000)
-  heartbeatTimer.unref?.()
   const close = () => {
     if (closePromise) return closePromise
     stopping = true
-    clearInterval(heartbeatTimer)
     clearTimeout(introTimer)
     clearInterval(sweepTimer)
     closePromise = (async () => {

package/studio/app.mjs

@@ -393,7 +393,7 @@ function initializeStudio() {
     $('open-model-settings').disabled = !agent.settingsEditable;
     $('open-agent-removal').disabled = !agent.removable;
     const watcherRunning = agent.status === 'online' || agent.watcherAlive === true;
-    $('toggle-watcher').textContent = watcherRunning ? 'Stop watcher' : 'Start watcher';
+    $('toggle-watcher').querySelector('span').textContent = watcherRunning ? 'Stop watcher' : 'Start watcher';
     $('toggle-watcher').dataset.action = watcherRunning ? 'stop' : 'start';
     $('toggle-watcher').disabled = watcherChanging || !agent.watcherControllable;
     $('restart-watcher').disabled = watcherChanging || !agent.watcherControllable;

package/studio/guide.html

@@ -33,7 +33,7 @@
         <main id="guide-content" class="guide-content" tabindex="-1">
           <section id="start">
             <h2>Open Studio</h2>
-            <p>Agent Studio is a local viewer for bring-your-own (BYO) agents connected to an OpenVisio team. It shows recorded actions from Claude Code, Codex, and OpenCode watchers on this machine.</p>
+            <p>Agent Studio is a local viewer for bring-your-own (BYO) agents connected to an OpenVisio team. It shows recorded actions from Claude Code, Codex, OpenCode, Gemini CLI, and Qwen Code watchers on this machine.</p>
             <p>In the OpenVisio app, open <strong>Agents → Open Agent Studio</strong>. Agents can also include this button in chat replies. Updated backend watchers start Studio automatically on this computer.</p>
             <p>You can also open Studio manually:</p>
             <pre><code>openvisio-agent studio</code></pre>
@@ -46,12 +46,12 @@
             <h2>Change models</h2>
             <p>Select an agent in the sidebar, choose <strong>Model settings</strong>, select its reply and coding models, then choose <strong>Save models</strong>. Model fields let you search the runtime’s choices or enter a custom model ID.</p>
             <p>Updated watchers load saved choices immediately and apply them to the next request without a restart. Work already running continues with its original model. After a request starts, Studio shows the model the runtime actually selected. Offline agents retain the selection for their next connection.</p>
-            <p>OpenCode choices come from its local model catalog. Listing a model does not guarantee credentials or available quota. If a model is rate-limited, choose one with available quota or retry after the provider’s limit resets.</p>
+            <p>Model choices come from the selected runtime’s local catalog. Listing a model does not guarantee credentials or available quota. If a model is rate-limited, choose one with available quota or retry after the provider’s limit resets.</p>
             <p>Studio controls agents configured on this computer. An agent running on another teammate’s computer must be managed there.</p>
           </section>
           <section id="remove">
             <h2>Remove a local agent</h2>
-            <p>Select an agent, choose <strong>Remove from computer</strong>, review the local data, and type its local name to confirm. Studio stops its watcher and background service, then removes its local connection credentials, logs, memory, and cached context. This cannot be undone.</p>
+            <p>Select an agent, choose <strong>Remove agent</strong>, review the local data, and type its local name to confirm. Studio stops its watcher and background service, then removes its local connection credentials, logs, memory, and cached context. This cannot be undone.</p>
             <p>Repositories, branches, shared model-provider logins, and the team’s agent profile stay in place. Context shared with another local connection is retained. Removal is available on macOS and Linux for the default local agent storage; custom state directories and Windows require manual management.</p>
           </section>
           <section id="watchers">
@@ -62,7 +62,7 @@
               <li>Select the agent in Studio and choose <strong>Start watcher</strong>. Studio installs its background watcher and starts it with the current package and saved model settings.</li>
               <li>Return to Studio. Your agent should appear in the sidebar. Select its name to see its activity.</li>
             </ol>
-            <p>Use <strong>Stop watcher</strong> to take an agent offline and <strong>Restart watcher</strong> after changing its runtime installation or troubleshooting a connection. Restarting preserves its configuration and model choices.</p>
+            <p>Use <strong>Stop watcher</strong> to take an agent offline and <strong>Restart watcher</strong> after changing its runtime installation or troubleshooting a connection. Restarting preserves its configuration and model choices. While connected and idle, the watcher waits for WebSocket or local settings events without starting a coding runtime or polling project activity.</p>
             <p>Watcher controls are available for backend agents in the default local agent storage on macOS and Linux. Their earlier activity cannot be reconstructed.</p>
           </section>
           <section id="find-work">

package/studio/index.html

@@ -34,6 +34,10 @@
       <symbol id="i-clock" viewBox="0 0 24 24"><circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/></symbol>
       <symbol id="i-close" viewBox="0 0 24 24"><path d="m6 6 12 12M6 18 18 6"/></symbol>
       <symbol id="i-copy" viewBox="0 0 24 24"><rect x="8" y="8" width="12" height="13" rx="2"/><path d="M16 8V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h3"/></symbol>
+      <symbol id="i-power" viewBox="0 0 24 24"><path d="M12 3v9"/><path d="M7.1 5.8a8 8 0 1 0 9.8 0"/></symbol>
+      <symbol id="i-refresh" viewBox="0 0 24 24"><path d="M20 7v5h-5"/><path d="M4 17v-5h5"/><path d="M6.1 8a7 7 0 0 1 11.7-1L20 12M4 12l2.2 5a7 7 0 0 0 11.7-1"/></symbol>
+      <symbol id="i-sliders" viewBox="0 0 24 24"><path d="M4 6h10M18 6h2M4 12h2m4 0h10M4 18h8m4 0h4"/><circle cx="16" cy="6" r="2"/><circle cx="8" cy="12" r="2"/><circle cx="14" cy="18" r="2"/></symbol>
+      <symbol id="i-user-minus" viewBox="0 0 24 24"><circle cx="9" cy="8" r="4"/><path d="M2 21a7 7 0 0 1 14 0M17 11h6"/></symbol>
     </defs></svg>
     <a class="skip-link" href="#workspace">Skip to activity</a>
     <div class="app-shell">
@@ -61,7 +65,7 @@
         <div id="notice" class="notice" role="status" hidden></div>
         <section id="model-settings-summary" class="model-settings-summary" aria-label="Agent model settings" hidden>
           <div><h2 id="model-settings-agent">Model settings</h2><p id="model-settings-state" role="status"></p></div>
-          <div class="header-actions"><button id="toggle-watcher" class="button" type="button">Start watcher</button><button id="restart-watcher" class="button" type="button">Restart watcher</button><button id="open-model-settings" class="button" type="button">Model settings</button><button id="open-agent-removal" class="button" type="button">Remove from computer</button></div>
+          <div class="header-actions model-settings-actions-row"><button id="toggle-watcher" class="button studio-action" type="button"><svg class="icon" aria-hidden="true"><use href="#i-power"/></svg><span>Start watcher</span></button><button id="restart-watcher" class="button studio-action restart-action" type="button"><svg class="icon" aria-hidden="true"><use href="#i-refresh"/></svg><span>Restart watcher</span></button><button id="open-model-settings" class="button studio-action settings-action" type="button"><svg class="icon" aria-hidden="true"><use href="#i-sliders"/></svg><span>Model settings</span></button><button id="open-agent-removal" class="button studio-action remove-action" type="button"><svg class="icon" aria-hidden="true"><use href="#i-user-minus"/></svg><span>Remove agent</span></button></div>
         </section>
         <dialog id="model-settings-dialog" aria-labelledby="model-settings-title">
           <form id="model-settings-form" class="model-settings-form">

package/studio/style.css

@@ -360,6 +360,13 @@
   .model-settings-summary:not([hidden]) { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 14px; padding: 18px; margin-bottom: 22px; border: 1px solid var(--border); border-radius: 20px; background: var(--surface, white); }
   .model-settings-summary h2 { margin: 0 0 6px; font-size: 13px; font-weight: 500; }
   .model-settings-summary p { margin: 0; color: var(--muted); font-size: 12px; overflow-wrap: anywhere; }
+  .model-settings-actions-row { gap: 8px; }
+  .studio-action .icon { transition: transform .16s ease-out, color .16s ease-out; }
+  .studio-action:hover .icon { transform: translateY(-1px); }
+  #toggle-watcher[data-action="start"] .icon { color: var(--success); }
+  #toggle-watcher[data-action="stop"] .icon, .remove-action .icon { color: var(--destructive); }
+  .restart-action .icon { color: var(--orange); }
+  .settings-action .icon { color: var(--purple); }
   #model-settings-dialog, #agent-removal-dialog { width: min(500px, calc(100vw - 32px)); max-height: calc(100dvh - 32px); margin: auto; padding: 24px; overflow-y: auto; border: 1px solid var(--border); border-radius: 24px; color: var(--ink); background: var(--surface, white); box-shadow: 0 24px 80px #0002; }
   #model-settings-dialog::backdrop, #agent-removal-dialog::backdrop { background: #0005; }
   .model-settings-form { display: grid; gap: 12px; }