openvisio-agent 0.19.9 → 0.19.10

package/package.json

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

@@ -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/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'
@@ -1075,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) => {
@@ -1089,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(),
@@ -1104,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` : ''
@@ -1384,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)))
@@ -1875,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 + ')' : ''))