openvisio-agent 0.19.0 → 0.19.1

package/README.md

@@ -58,6 +58,8 @@ Runs the **autonomy loop** — the agent replies to @mentions and picks up ticke
 
 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.
 
+Model names are negotiated at session start. Codex and OpenCode match the configured name against the models advertised by ACP, preferring the same family and reasoning effort (`medium` for an unsuffixed family); provider-qualified and nearby generation names are resolved automatically. Claude versioned names are normalized to its stable `sonnet`, `opus`, `haiku`, or `fable` aliases and use the CLI's native ordered fallback chain.
+
 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. 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 five minutes as a safety net; a model starts only when pending work exists.
 
 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openvisio-agent",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "Connect Claude Code, Codex, or OpenCode to an OpenVisio team — MCP tools + optional autonomy — in one command.",
   "type": "module",
   "bin": {

package/scripts/certify.mjs

@@ -32,6 +32,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 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')
 const liveTasks = readFileSync(join(repo, 'frontend', 'lib', 'collab', 'liveTasks.ts'), 'utf8')
@@ -74,6 +75,7 @@ const assertions = [
   ['MCP requests have a deadline including response bodies', mcpHttp.includes('controller.abort()') && mcpHttp.includes('const body = await 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 isolated Mastra ACP sessions', watcher.includes('createMastraAcpRunner') && mastraHarness.includes('new AcpAgentClass') && mastraHarness.includes('persistSession: false') && mastraHarness.includes("runtime: 'mastra-acp'")],
+  ['runtime models are resolved before work starts', mastraHarness.includes('getAvailableModels()') && mastraHarness.includes('resolveAvailableModel(requestedModel') && mastraHarness.includes('await acp.setModel(selectedModel)') && modelSelection.includes("const DEFAULT_EFFORT = 'medium'") && watcher.includes('resolveClaudeModel') && watcher.includes("'--fallback-model'" )],
   ['one watcher owns isolated concurrent work and serial reply runtimes', watcher.includes('MAX_CONCURRENT_WORKERS = 3') && watcher.includes('createWorkRunner(item.control, item.workdir)') && watcher.includes('const replyRunner = createCycleRunner')],
   ['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(entry.group)')],
   ['work and reply cancellation targets are isolated', watcher.includes('item.control.cancelled = true') && watcher.includes('item.control.runner?.cancelCurrent')],

package/src/mastra-harness.mjs

@@ -2,6 +2,7 @@ import { spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { AcpAgent } from '@mastra/acp'
 import { onPath } from './lib.mjs'
+import { resolveAvailableModel } from './model-selection.mjs'
 
 const MCP_TOOL_NAMES = [
   'list_agents', 'list_projects', 'list_tasks', 'list_task_types', 'get_ticket',
@@ -97,7 +98,6 @@ export function createMastraAcpRunner({
         mcpServers,
       },
       persistSession: false,
-      ...(cycleModel || model ? { model: cycleModel || model } : {}),
       onPermissionRequest: async ({ options }) => {
         const kind = canCode ? 'allow_once' : 'reject_once'
         const selected = options.find((option) => option.kind === kind) || options.find((option) => option.kind.startsWith(canCode ? 'allow' : 'reject'))
@@ -114,9 +114,22 @@ export function createMastraAcpRunner({
       }) : undefined,
     })
     active = { acp, controller }
-    const timer = setTimeout(() => { timedOut = true; controller.abort() }, maxCycleMs)
-    log(`running ${agent} cycle via Mastra ACP…${cycleModel || model ? ` [${cycleModel || model}]` : ''}`)
+    const timer = setTimeout(() => { timedOut = true; controller.abort(); acp.connection.disconnect() }, maxCycleMs)
+    const requestedModel = cycleModel || model || ''
+    let selectedModel = ''
     try {
+      if (requestedModel) {
+        const availableModels = await acp.getAvailableModels()
+        const resolution = resolveAvailableModel(requestedModel, availableModels)
+        selectedModel = resolution.selected
+        if (selectedModel) {
+          await acp.setModel(selectedModel)
+          if (selectedModel !== requestedModel) log(`model ${requestedModel} resolved to available ${selectedModel} [${resolution.reason}]`)
+        } else {
+          log(`model ${requestedModel} could not be negotiated because ${agent} did not advertise selectable models; using its session default`)
+        }
+      }
+      log(`running ${agent} cycle via Mastra ACP…${selectedModel || requestedModel ? ` [${selectedModel || requestedModel}]` : ' [runtime default]'}`)
       const fullPrompt = systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt
       for await (const event of acp.connection.promptStream(fullPrompt, controller.signal)) {
         if (event.type === 'text') { outputText += event.text; continue }
@@ -152,7 +165,7 @@ export function createMastraAcpRunner({
       didResultMessage = didChannelMessage && didRepoMutation
       log(`${agent} cycle done via Mastra ACP (ok)`)
       return {
-        type: 'result', subtype: 'ok', runtime: 'mastra-acp', outputText: outputText.trim(),
+        type: 'result', subtype: 'ok', runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),
         mcpCalls: [...calls], mcpErrors: [...errors.keys()], mcpErrorDetails: Object.fromEntries(errors),
         didCode, didRepoMutation, didMessage, didChannelMessage, didResultMessage,
         didMcpTaskRead, didMcpTaskUpdate,
@@ -162,7 +175,7 @@ export function createMastraAcpRunner({
       const subtype = timedOut ? 'timeout' : canceled ? 'canceled' : 'error'
       log(`${agent} cycle done via Mastra ACP (${subtype}${!canceled && error?.message ? ': ' + clean(error.message) : ''})`)
       return {
-        type: 'result', subtype, runtime: 'mastra-acp', outputText: outputText.trim(),
+        type: 'result', subtype, runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),
         mcpCalls: [...calls], mcpErrors: [...errors.keys()], mcpErrorDetails: Object.fromEntries(errors),
         didCode, didRepoMutation, didMessage, didChannelMessage, didResultMessage,
         didMcpTaskRead, didMcpTaskUpdate,
@@ -178,6 +191,7 @@ export function createMastraAcpRunner({
     if (!active) return
     active.controller.abort()
     try { await active.acp.connection.cancel() } catch { /* already stopped */ }
+    active.acp.connection.disconnect()
   }
 
   log(`${agent} Mastra ACP runner ready${canCode ? ` [CODE workspace ${defaultCwd}]` : ' [CHAT-ONLY]'}`)

package/src/model-selection.mjs

@@ -0,0 +1,75 @@
+const EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra']
+const DEFAULT_EFFORT = 'medium'
+
+const text = (value) => String(value ?? '').trim()
+const lower = (value) => text(value).toLowerCase()
+
+function parts(value) {
+  const raw = text(value)
+  const effortMatch = /\[([^\]]+)\]$/.exec(raw)
+  const withoutEffort = effortMatch ? raw.slice(0, effortMatch.index) : raw
+  const path = lower(withoutEffort).split('/').filter(Boolean)
+  const leaf = path.at(-1) || ''
+  const tokens = leaf.split(/[^a-z0-9]+/).filter(Boolean)
+  return { raw, id: lower(raw), base: lower(withoutEffort), leaf, tokens, provider: path.slice(0, -1).join('/'), effort: lower(effortMatch?.[1]) }
+}
+
+const effortDistance = (actual, preferred) => {
+  const actualIndex = EFFORTS.indexOf(actual)
+  const preferredIndex = EFFORTS.indexOf(preferred)
+  if (actualIndex < 0) return 20
+  return Math.abs(actualIndex - (preferredIndex < 0 ? EFFORTS.indexOf(DEFAULT_EFFORT) : preferredIndex))
+}
+
+function similarity(requested, candidate, preferredEffort) {
+  if (candidate.id === requested.id) return 100_000
+  let score = 0
+  if (candidate.base === requested.base || candidate.leaf === requested.leaf) score += 50_000
+  if (requested.provider && candidate.provider === requested.provider) score += 2_000
+  const requestedTokens = new Set(requested.tokens)
+  const shared = candidate.tokens.filter((token) => requestedTokens.has(token)).length
+  score += shared * 1_000
+  if (requested.leaf && (candidate.leaf.includes(requested.leaf) || requested.leaf.includes(candidate.leaf))) score += 10_000
+  let prefix = 0
+  while (prefix < requested.leaf.length && prefix < candidate.leaf.length && requested.leaf[prefix] === candidate.leaf[prefix]) prefix++
+  score += prefix * 10
+  score -= effortDistance(candidate.effort, requested.effort || preferredEffort) * 100
+  return score
+}
+
+export function resolveAvailableModel(requestedValue, availableModels = [], { preferredEffort = DEFAULT_EFFORT } = {}) {
+  const requested = parts(requestedValue)
+  const choices = availableModels.map((entry) => typeof entry === 'string' ? entry : entry?.modelId).map(text).filter(Boolean)
+  if (!choices.length) return { requested: requested.raw, selected: '', reason: 'runtime-default', available: [] }
+  if (!requested.raw) return { requested: '', selected: '', reason: 'runtime-default', available: choices }
+
+  const ranked = choices.map((id, index) => {
+    const candidate = parts(id)
+    return { id, index, score: similarity(requested, candidate, preferredEffort) }
+  }).sort((a, b) => b.score - a.score || a.index - b.index)
+  const winner = ranked[0]
+  return {
+    requested: requested.raw,
+    selected: winner.id,
+    reason: lower(winner.id) === requested.id ? 'exact' : parts(winner.id).base === requested.base || parts(winner.id).leaf === requested.leaf ? 'family-effort' : 'nearest',
+    available: choices,
+  }
+}
+
+const CLAUDE_FAMILIES = ['sonnet', 'opus', 'haiku', 'fable']
+
+export function resolveClaudeModel(requestedValue) {
+  const requested = lower(requestedValue)
+  if (!requested) return ''
+  const family = CLAUDE_FAMILIES.find((name) => requested === name || requested.startsWith('claude-') && requested.includes(name))
+  return family || text(requestedValue)
+}
+
+export function claudeFallbackModels(selectedValue) {
+  const selected = lower(selectedValue)
+  const preferred = selected === 'opus' ? ['sonnet', 'haiku']
+    : selected === 'haiku' ? ['sonnet', 'opus']
+      : selected === 'fable' ? ['sonnet', 'opus'] : ['opus', 'haiku']
+  return preferred.filter((model) => model !== selected)
+}
+

package/src/watch.mjs

@@ -20,6 +20,7 @@ import { buildCodexMcpOverride } from './codex-config.mjs'
 import { createCycleQueue } from './cycle-queue.mjs'
 import { modelProcessOptions, stopModelProcess } from './process-lifecycle.mjs'
 import { createMastraAcpRunner } from './mastra-harness.mjs'
+import { claudeFallbackModels, resolveClaudeModel } from './model-selection.mjs'
 
 function findTicketWorktree(workspaceRoot, ticketId) {
   if (!workspaceRoot || ticketId == null) return ''
@@ -613,7 +614,7 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
   // 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
   // session so the new model takes effect.
-  let sessionModel = model || null
+  let sessionModel = resolveClaudeModel(model) || null
   let turnsThisSession = 0
   let sessionStartedAt = 0
   let resolveTurn = null
@@ -670,7 +671,8 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
     if (!mcpConfig) { log('WARNING: no MCP config — the agent can react to events but has no tools to act. Re-connect with --mcp-url.') }
     // The charter + creds ride in the system prompt (cacheable → not re-billed each
     // cycle), leaving only the small per-cycle instruction in the user message.
-    const base = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--strict-mcp-config', '--mcp-config', mcpConfig, ...(sessionModel ? ['--model', sessionModel] : []), ...(systemPrompt ? ['--append-system-prompt', systemPrompt] : [])]
+    const fallbackModels = claudeFallbackModels(sessionModel)
+    const base = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--strict-mcp-config', '--mcp-config', mcpConfig, ...(sessionModel ? ['--model', sessionModel, ...(fallbackModels.length ? ['--fallback-model', fallbackModels.join(',')] : [])] : []), ...(systemPrompt ? ['--append-system-prompt', systemPrompt] : [])]
     const args = canCode ? [...base, '--allowedTools', ...CODE_TOOLS, '--disallowedTools', ...DENY_TOOLS] : [...base, '--allowedTools', 'mcp__openvisio-team__*']
     const c = spawn(claude, args, { ...modelProcessOptions, cwd: workdir || undefined, stdio: ['pipe', 'pipe', 'inherit'] })
     child = c
@@ -731,9 +733,11 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
     return new Promise((resolve) => {
       // A per-cycle model override (e.g. chat on a cheaper model than code) — a
       // change means the warm session must be respawned with the new --model.
-      if (cycleModel && cycleModel !== sessionModel) {
-        if (child) { log('model change ' + (sessionModel || 'default') + ' → ' + cycleModel + ' — recycling session'); try { child.kill() } catch { /* gone */ } child = null }
-        sessionModel = cycleModel
+      const resolvedCycleModel = resolveClaudeModel(cycleModel)
+      if (resolvedCycleModel && resolvedCycleModel !== sessionModel) {
+        if (child) { log('model change ' + (sessionModel || 'default') + ' → ' + resolvedCycleModel + ' — recycling session'); try { child.kill() } catch { /* gone */ } child = null }
+        if (resolvedCycleModel !== cycleModel) log('model ' + cycleModel + ' resolved to Claude family alias ' + resolvedCycleModel)
+        sessionModel = resolvedCycleModel
       }
       if (child && (turnsThisSession >= MAX_TURNS || Date.now() - sessionStartedAt > SESSION_IDLE_MS)) {
         log('recycling session (turns=' + turnsThisSession + ')')