openvisio-agent 0.19.8 → 0.19.10

package/README.md

@@ -58,7 +58,7 @@ 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.
+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. 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openvisio-agent",
-  "version": "0.19.8",
+  "version": "0.19.10",
   "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

@@ -77,7 +77,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 warm scoped Mastra ACP sessions', watcher.includes('createMastraAcpRunner') && watcher.includes('const replyRunners = new Map()') && watcher.includes('replyRunnerFor(item.delivery)') && mastraHarness.includes('new AcpAgentClass') && mastraHarness.includes('persistSession: true') && 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'" )],
+  ['runtime models are selected explicitly before work starts', mastraHarness.includes('getAvailableModels()') && mastraHarness.includes('resolveAvailableModel(requestedModel') && mastraHarness.includes('await acp.setModel(resolution.selected)') && modelSelection.includes('automatic model substitution is disabled') && watcher.includes('if (changed) persistModel()')],
   ['one watcher owns isolated concurrent work and thread-scoped serial reply runtimes', watcher.includes('MAX_CONCURRENT_WORKERS = 3') && watcher.includes('createWorkRunner(item.control, item.workdir)') && watcher.includes('const replyRunners = new Map()') && watcher.includes('while (replyRunners.size > 8)')],
   ['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')],
@@ -128,7 +128,7 @@ const assertions = [
   ['policy blocker is surfaced to the user', watcher.includes('reportPolicyBlock(prompt, activeTaskRef, result.policyBlock, delivery)') && watcher.includes("Action required: I'm blocked")],
   ['blocker routing carries explicit task identity', watcher.includes('const activeTaskRef = taskRef') && watcher.includes('taskRef: activeTaskRef')],
   ['reply discovery failures stay scoped while failed mutations fail closed', watcher.includes('blockingReplyMcpErrors(result?.mcpErrors)') && watcher.includes('preserving the scoped model reply') && events.includes('export function blockingReplyMcpErrors')],
-  ['pending-ticket questions use watcher-owned MCP reads without a model cycle', watcher.includes('conversationAsksPendingTickets(text)') && watcher.includes('pending-ticket question -> watcher-owned MCP lookup') && watcher.includes("callMcpReadWithRetry('list_tasks'") && !watcher.includes("callMcpReadWithRetry('list_agents'")],
+  ['pending-ticket questions use watcher-owned MCP reads without a chat model cycle', watcher.includes('conversationAsksPendingTickets(text)') && watcher.includes('pending-ticket question -> watcher-owned MCP lookup') && watcher.includes("callMcpReadWithRetry('list_tasks'") && watcher.includes("if (selfAgentId == null) {\n      const agentsData = toolData(await callMcpReadWithRetry('list_agents'))")],
   ['chat ACP allows opaque MCP approvals behind a strict read-only proxy', mastraHarness.includes('export function acpPermissionResponse') && mastraHarness.includes('opaqueMcpApproval') && mastraHarness.includes('OPENVISIO_CODEX_ALLOWED_TOOLS') && codexProxy.includes('export function toolAllowed') && codexProxy.includes('allowedTools.has(name)')],
   ['all runtime blockers have a delivery path', watcher.includes('publishBlocker') && watcher.includes('WORK_CYCLE_BLOCKED') && watcher.includes('COORDINATION_CYCLE_BLOCKED')],
   ['ticket blocker cannot self-authorize', watcher.includes("ticketNotice = `I'm paused") && watcher.includes('publishBlocker({ prompt, taskRef, delivery, notice, ticketNotice, pause: true })') && !watcher.includes('test(approvalText)')],

package/src/assignment-routing.mjs

@@ -0,0 +1,32 @@
+// Assignment requests are routed by the watcher, before the restricted chat
+// runtime can mistake its own tool limits for the coding worker's capabilities.
+export function assignmentStatusOnly(value) {
+  return /\b(?:do not|don't|dont|stop|cancel|stand down|status only|just (?:list|check|tell|show)|only (?:list|check|tell|show))\b/i.test(String(value || ''))
+}
+
+export function assignmentRequest(value) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim()
+  if (assignmentStatusOnly(text)) return null
+  const slugs = [...new Set((text.match(/\b[a-z][a-z0-9]*-\d+\b/gi) || []).map((slug) => slug.toUpperCase()))]
+  const tickets = /\b(?:tickets?|tasks?|assignments?|backlog)\b/i.test(text) || slugs.length > 0
+  const action = /\b(?:start|begin|resume|continue|implement|fix|finish|complete|handle|execute|dispatch|pick\s+up|work\s+(?:on|through))\b/i.test(text)
+  const assigned = /\b(?:assigned|gave)\s+(?:\S+\s+){0,3}you\b|\byou\s+have\b.*\b(?:pending|assigned)\b/i.test(text)
+  return tickets && (action || assigned) ? { slugs } : null
+}
+
+export async function routeAssignments({ request, loadTickets, handleTask, isCancelled = () => false }) {
+  const tickets = await loadTickets()
+  const selected = tickets.filter((ticket) => !request.slugs.length || request.slugs.includes(ticket.slug))
+  // A project-scoped slug must resolve uniquely before any work is started.
+  for (const slug of request.slugs) {
+    if (selected.filter((ticket) => ticket.slug === slug).length !== 1) {
+      throw new Error(`I couldn't uniquely resolve ${slug} among my open assignments.`)
+    }
+  }
+  const actionable = selected.filter((ticket) => !ticket.awaitingReview)
+  for (const ticket of actionable) {
+    if (isCancelled()) return
+    await handleTask('task:assigned', { task: { id: ticket.id, project_id: ticket.projectId } })
+  }
+  return actionable.length
+}

package/src/mastra-harness.mjs

@@ -98,7 +98,7 @@ export function createMastraAcpRunner({
     const headers = Object.entries(mcpHeaders).filter(([, value]) => value != null && value !== '').map(([name, value]) => ({ name, value: String(value) }))
     const disabledMcpTools = Array.isArray(cycleOptions.disabledMcpTools) ? cycleOptions.disabledMcpTools.filter(Boolean) : []
     const mcpServers = !mcpUrl ? [] : agent === 'codex' ? [{
-      name: 'openvisio-team', command: process.execPath, args: [proxyPath], env: [
+      name: 'openvisio-team-watcher', command: process.execPath, args: [proxyPath], env: [
         { name: 'OPENVISIO_CODEX_MCP_URL', value: mcpUrl },
         { name: 'OPENVISIO_CODEX_API_KEY', value: String(mcpHeaders['x-agent-api-key'] || '') },
         { name: 'OPENVISIO_CODEX_IDENTIFIER', value: String(mcpHeaders['x-agent-identifier'] || '') },
@@ -119,6 +119,10 @@ export function createMastraAcpRunner({
         env: agent === 'codex' ? {
           INITIAL_AGENT_MODE: canCode ? 'agent' : 'read-only',
           NO_BROWSER: '1',
+          // codex-acp otherwise keeps a pre-existing openvisio-team server and
+          // silently discards this session's authenticated stdio bridge.
+          DISABLE_MCP_CONFIG_FILTERING: 'true',
+          CODEX_CONFIG: JSON.stringify({ 'mcp_servers.openvisio-team.enabled': false }),
         } : {},
         session: {
           cwd: cycleCwd,
@@ -161,9 +165,9 @@ export function createMastraAcpRunner({
         if (requestedModel !== negotiatedRequested) {
           const availableModels = await acp.getAvailableModels()
           const resolution = resolveAvailableModel(requestedModel, availableModels)
-          selectedModel = resolution.selected
-          if (selectedModel) {
-            await acp.setModel(selectedModel)
+          if (resolution.selected) {
+            await acp.setModel(resolution.selected)
+            selectedModel = resolution.selected
             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`)
@@ -209,7 +213,9 @@ export function createMastraAcpRunner({
       const after = repositorySnapshot(canCode ? cycleCwd : '')
       if (before !== after) { didCode = true; didRepoMutation = true }
       didResultMessage = didChannelMessage && didRepoMutation
-      log(`${agent} cycle done via Mastra ACP (ok)`)
+      const redact = (value) => Object.values(mcpHeaders).filter(Boolean).reduce((safe, secret) => safe.split(String(secret)).join('[redacted]'), String(value))
+      for (const [name, detail] of errors) log(`MCP ${name} failed: ${redact(detail)}`)
+      log(`${agent} cycle done via Mastra ACP (${errors.size ? 'tool-errors' : 'ok'})`)
       return {
         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),
@@ -219,7 +225,9 @@ export function createMastraAcpRunner({
     } catch (error) {
       const canceled = controller.signal.aborted
       const subtype = timedOut ? 'timeout' : canceled ? 'canceled' : 'error'
-      log(`${agent} cycle done via Mastra ACP (${subtype}${!canceled && error?.message ? ': ' + clean(error.message) : ''})`)
+      const errorDetail = [error?.message, error?.data ? json(error.data) : ''].filter(Boolean).join(': ')
+      const safeError = Object.values(mcpHeaders).filter(Boolean).reduce((safe, secret) => safe.split(String(secret)).join('[redacted]'), errorDetail)
+      log(`${agent} cycle done via Mastra ACP (${subtype}${!canceled && safeError ? ': ' + clean(safeError, 1200) : ''})`)
       invalidate()
       return {
         type: 'result', subtype, runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),

package/src/model-selection.mjs

@@ -40,10 +40,18 @@ function similarity(requested, candidate, preferredEffort) {
 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 (!choices.length && requested.raw) return { requested: requested.raw, selected: requested.raw, reason: 'explicit-unadvertised', available: [] }
+  if (!choices.length) return { requested: '', selected: '', reason: 'runtime-default', available: [] }
   if (!requested.raw) return { requested: '', selected: '', reason: 'runtime-default', available: choices }
 
-  const ranked = choices.map((id, index) => {
+  const compatible = choices.filter((id) => {
+    const candidate = parts(id)
+    return candidate.id === requested.id || (!requested.effort &&
+      candidate.leaf === requested.leaf && (!requested.provider || candidate.provider === requested.provider) &&
+      (!candidate.effort || candidate.effort === preferredEffort))
+  })
+  if (!compatible.length) throw new Error(`Configured model "${requested.raw}" is unavailable; automatic model substitution is disabled.`)
+  const ranked = compatible.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)
@@ -59,17 +67,9 @@ export function resolveAvailableModel(requestedValue, availableModels = [], { pr
 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)
+  return 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)
+  return []
 }
-

package/src/watch.mjs

@@ -18,6 +18,7 @@ import { createMcpHttpClient } from './mcp-http.mjs'
 import { buildOpencodeConfig, opencodeRuntimeLayout } from './opencode-config.mjs'
 import { buildCodexMcpOverride } from './codex-config.mjs'
 import { createCycleQueue } from './cycle-queue.mjs'
+import { assignmentRequest, assignmentStatusOnly, routeAssignments } from './assignment-routing.mjs'
 import { modelProcessOptions, stopModelProcess } from './process-lifecycle.mjs'
 import { createMastraAcpRunner } from './mastra-harness.mjs'
 import { claudeFallbackModels, resolveClaudeModel } from './model-selection.mjs'
@@ -261,10 +262,9 @@ 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 */ } }
 
-  // Codex uses Sol for every watcher cycle. Reliability and consistent MCP/tool
-  // behaviour take priority over maintaining a cheaper coordination lane.
-  const defaultModel = agent === 'claude' ? 'sonnet' : agent === 'codex' ? 'gpt-5.6-sol' : ''
-  const defaultChatModel = agent === 'claude' ? 'haiku' : agent === 'codex' ? 'gpt-5.6-sol' : ''
+  // 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]' : ''
   const model = String(flags.model || (saved && saved.model) || defaultModel)
   const chatModel = String(flags['chat-model'] || (saved && saved.chatModel) || defaultChatModel)
 
@@ -1076,6 +1076,12 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   }
 
   const loadPendingTickets = async () => {
+    if (selfAgentId == null) {
+      const agentsData = toolData(await callMcpReadWithRetry('list_agents'))
+      const self = (Array.isArray(agentsData.agents) ? agentsData.agents : []).find((a) => String(a.identifier || a.slug || '') === identifier)
+      if (!self?.id) throw new Error('list_agents did not return this BYO agent')
+      rememberSelfAgent(self)
+    }
     const projectsData = toolData(await callMcpReadWithRetry('list_projects'))
     const projects = Array.isArray(projectsData.projects) ? projectsData.projects : []
     const groups = await Promise.all(projects.filter((project) => project?.id != null).map(async (project) => {
@@ -1090,12 +1096,16 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const typesData = typesResult ? toolData(typesResult) : {}
       const types = Array.isArray(typesData.types) ? typesData.types : Array.isArray(typesData.task_types) ? typesData.task_types : Array.isArray(typesData.taskTypes) ? typesData.taskTypes : []
       const doneIds = new Set(types.filter((type) => /\b(?:done|complete|completed|closed|cancelled|canceled|archived|resolved)\b/i.test(String(type.name || ''))).map((type) => Number(type.id)))
+      const reviewIds = new Set(types.filter((type) => /\b(?:review|test|testing|qa|quality\s+assurance|verification|approval)\b/i.test(String(type.name || ''))).map((type) => Number(type.id)))
       return (Array.isArray(tasksData.tasks) ? tasksData.tasks : []).filter((task) => {
         const assignedId = Number(taskAgentId(task) ?? task.agent?.id ?? task.assigned_agent?.id)
         const assignedIdentifier = String(task.agent?.identifier ?? task.agent?.slug ?? task.assigned_agent?.identifier ?? task.assigned_agent?.slug ?? '')
         const assignedHere = (selfAgentId != null && assignedId === selfAgentId) || assignedIdentifier === identifier
         return assignedHere && !taskIsCompleted(task, doneIds)
       }).map((task) => ({
+        id: task.id,
+        projectId: project.id,
+        awaitingReview: taskIsAwaitingReview(task, reviewIds),
         slug: ticketDisplaySlug(task),
         title: String(task.title || 'Untitled ticket'),
         state: String(task.type?.name ?? task.task_type?.name ?? task.status ?? '').trim(),
@@ -1105,9 +1115,17 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     return groups.flat()
   }
 
-  const answerPendingTickets = async ({ delivery, who }) => {
+  const answerPendingTickets = async ({ delivery, who, text }) => {
     try {
       const tickets = await loadPendingTickets()
+      // Assignments already authorize pickup. A board lookup should not leave
+      // discovered work idle until a second human nudge arrives.
+      if (canCode && !assignmentStatusOnly(text)) {
+        await routeAssignments({
+          request: { slugs: [] }, loadTickets: async () => tickets, handleTask: handleTaskSignal,
+          isCancelled: () => memory.has(threadControlKey(delivery?.channelId, delivery?.parentId), 'cancelled'),
+        })
+      }
       const prefix = who ? `@${who} ` : ''
       const details = tickets.slice(0, 8).map((ticket) => `${ticket.slug || ticket.title}${ticket.slug ? ` “${ticket.title}”` : ''}${ticket.state ? ` (${ticket.state})` : ''}${ticket.project ? ` in ${ticket.project}` : ''}`)
       const extra = tickets.length > details.length ? `, plus ${tickets.length - details.length} more` : ''
@@ -1385,7 +1403,12 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         const [tasksData, typesData, activityData] = await Promise.all([
           callMcpTool('list_tasks', { project_id: project.id }).then(toolData),
           callMcpTool('list_task_types', { project_id: project.id }).then(toolData),
-          callMcpTool('list_activity', { project_id: project.id }).then(toolData),
+          // Chat history is optional for assignment pickup. An unavailable
+          // activity feed must not strand otherwise verified pending tickets.
+          callMcpTool('list_activity', { project_id: project.id }).then(toolData).catch((error) => {
+            log('activity reconciliation unavailable: ' + (error?.message || error))
+            return {}
+          }),
         ])
         const taskTypes = Array.isArray(typesData.types) ? typesData.types : Array.isArray(typesData.task_types) ? typesData.task_types : Array.isArray(typesData.taskTypes) ? typesData.taskTypes : []
         const doneIds = new Set(taskTypes.filter((t) => /\b(?:done|complete|completed|closed|cancelled|canceled|archived|resolved)\b/i.test(String(t.name || ''))).map((t) => Number(t.id)))
@@ -1562,7 +1585,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const prompt = (ctx.length ? ctx.join('\n') + '\n\n' : '') + (recalled ? recalled + '\n\n' : '') + baseFor(kind, delivery)
     // Chat-shaped cycles (mentions/intro) may run on the cheaper chat model; code
     // work (full/sweep) uses the main model.
-    const useModel = agent === 'codex' ? codeModel : kind === 'full' ? codeModel : liteModel
+    const useModel = kind === 'full' ? codeModel : liteModel
     log('running ' + kind + ' cycle…' + (ctx.length ? ' (' + ctx.length + ' event' + (ctx.length === 1 ? '' : 's') + ')' : '') + (useModel ? ' [' + useModel + ']' : ''))
     // Presence notifications are intentionally disabled; durable messages and
     // ticket transitions are the only user-visible progress signals.
@@ -1584,6 +1607,14 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       }
       if (cycleControl.cancelled) return
       const result = await runner.runCycle(prompt, useModel, runnerOptions)
+      if (result?.model && result.model !== useModel) {
+        // Persist only a successfully selected model and only if the user has
+        // not changed that tier while this cycle was running.
+        let changed = false
+        if (codeModel === useModel) { codeModel = result.model; changed = true }
+        if (liteModel === useModel) { liteModel = result.model; changed = true }
+        if (changed) persistModel()
+      }
       let completionResult = result
       if (cycleControl.cancelled || result?.subtype === 'canceled') {
         log(laneName + ' cycle cancelled; no blocker or reply will be published')
@@ -1686,9 +1717,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const x = String(s || '').toLowerCase().replace(/[.,!?]+$/, '')
     if (x === 'opus' || x === 'sonnet' || x === 'haiku') return x
     if (/^claude-[a-z0-9.\-\[\]]+$/i.test(x)) return x
-    if (/^(?:gpt|codex|o[1-9])[a-z0-9.\-:]*$/i.test(x)) return x
+    if (/^(?:gpt|codex|o[1-9])[a-z0-9.\-:]*(?:\[(?:low|medium|high|xhigh|max|ultra)\])?$/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
+    return /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9.\-:]*(?:\[(?:low|medium|high|xhigh|max|ultra)\])?$/i.test(x) ? x : null
   }
   // Optional target tier: "chat"/"lite" → chat cycles only, "code"/"full" → code
   // cycles only, absent → both.
@@ -1868,9 +1899,29 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         }
         return
       }
+      const assignment = assignmentRequest(text)
+      if (assignment) {
+        const delivery = conversationDelivery('assignment-routing')
+        const isCancelled = () => !!controlKey && memory.has(controlKey, 'cancelled')
+        // Enqueue each verified ticket separately, using the same ownership,
+        // revision and queue dedupe gates as live assignment events.
+        void (async () => {
+          try {
+            if (!canCode) throw new Error('This watcher is configured with --chat-only and has no coding worker. Enable its coding workspace to execute assigned tickets.')
+            const count = await routeAssignments({ request: assignment, loadTickets: loadPendingTickets, handleTask: handleTaskSignal, isCancelled })
+            if (count === 0 && delivery && !isCancelled()) {
+              await postMessageOnce({ ...delivery, content: `${who ? `@${who} ` : ''}I have no open assignments ready for implementation; tickets awaiting review or testing stay in their current stage.` })
+            }
+          } catch (error) {
+            log('assignment routing failed: ' + (error?.message || error))
+            if (delivery && !isCancelled()) await postMessageOnce({ ...delivery, content: `${who ? `@${who} ` : ''}I couldn't route the assigned work: ${error?.message || error}` })
+          }
+        })().catch((error) => log('assignment routing delivery failed: ' + (error?.message || error)))
+        return
+      }
       if (cid != null && conversationAsksPendingTickets(text)) {
         log('pending-ticket question -> watcher-owned MCP lookup')
-        void answerPendingTickets({ delivery: conversationDelivery('pending-tickets'), who })
+        void answerPendingTickets({ delivery: conversationDelivery('pending-tickets'), who, text })
         return
       }
       log('agent:mention in channel ' + (cid != null ? cid : '?') + (threadRoot != null ? ' (thread ' + threadRoot + ')' : ''))