openvisio-agent 0.17.1 → 0.17.2

package/package.json

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

@@ -42,7 +42,9 @@ const assertions = [
   ['Codex policy rejection is captured from stderr', watcher.includes("stdio: ['ignore', 'pipe', 'pipe']") && watcher.includes('inspectDiagnostic(d)')],
   ['policy rejection cannot be logged as successful', watcher.includes("subtype = policyBlock ? 'blocked'")],
   ['policy-blocked tickets are persisted and paused', watcher.includes('blockedTasks: [...blockedTasks]') && watcher.includes('WORK_CYCLE_BLOCKED')],
-  ['policy blocker is surfaced to the user', watcher.includes('reportPolicyBlock(prompt, result.policyBlock)') && watcher.includes('[Agent action required]')],
+  ['policy blocker is surfaced to the user', watcher.includes('reportPolicyBlock(prompt, activeTaskRef, result.policyBlock)') && watcher.includes('Action required: Alex is blocked')],
+  ['blocker routing carries explicit task identity', watcher.includes('taskRefs: []') && watcher.includes('activeTaskRef') && watcher.includes('taskRef: activeTaskRef')],
+  ['all runtime blockers have a delivery path', watcher.includes('publishBlocker') && watcher.includes('WORK_CYCLE_BLOCKED') && watcher.includes('COORDINATION_CYCLE_BLOCKED')],
   ['normative certification gates are documented', spec.includes('## Mandatory certification gates')],
 ]
 for (const [label, ok] of assertions) {

package/src/events.mjs

@@ -54,7 +54,9 @@ export function codexPolicyBlock(value) {
   const command = /exec_command failed for [`']([^`']+)[`']/.exec(text)?.[1] || ''
   const reasonTail = text.split(/Reason:\s*/i)[1] || ''
   const reason = reasonTail.split(/(?:\\n|\n)The agent\b/i)[0].replace(/[\\"') }]+$/, '').trim() || 'Codex requires explicit user approval for this external action.'
-  return { kind: 'authorization-required', command, reason: reason.slice(0, 900) }
+  const commit = /\bcommit\s+([0-9a-f]{7,40})\b/i.exec(reason)?.[1] || ''
+  const push = /\bgit\s+push(?:\s+-\S+)*(?:\s+\S+)*\s+(\S+)\s+(\S+)\s*$/i.exec(command)
+  return { kind: 'authorization-required', command, reason: reason.slice(0, 900), commit, remote: push?.[1] || '', branch: push?.[2] || '' }
 }
 
 // A mention event means this agent's name appeared somewhere, not necessarily

package/src/watch.mjs

@@ -593,8 +593,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   let liteModel = chatModel || model
 
   const lanes = {
-    work: { busy: false, queued: null, pending: [], targets: new Set() },
-    reply: { busy: false, queued: null, pending: [], targets: new Set() },
+    work: { busy: false, queued: null, pending: [], targets: new Set(), taskRefs: [] },
+    reply: { busy: false, queued: null, pending: [], targets: new Set(), taskRefs: [] },
   }
   // Tasks we've already reacted to (keyed task-id:agent — so a REASSIGNMENT to a
   // different agent re-triggers), so a noisy stream of task:updated events doesn't
@@ -650,7 +650,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   }
   const ensureMcpSession = async () => {
     if (mcpSessionId) return
-    const res = await mcpPost({ jsonrpc: '2.0', id: ++mcpRpcId, method: 'initialize', params: { protocolVersion: '2025-03-26', capabilities: {}, clientInfo: { name: 'openvisio-agent', version: '0.17.1' } } }, false)
+    const res = await mcpPost({ jsonrpc: '2.0', id: ++mcpRpcId, method: 'initialize', params: { protocolVersion: '2025-03-26', capabilities: {}, clientInfo: { name: 'openvisio-agent', version: '0.17.2' } } }, false)
     if (!res.ok) throw new Error('MCP initialize HTTP ' + res.status)
     await mcpPayload(res)
     mcpSessionId = res.headers.get('mcp-session-id') || ''
@@ -701,44 +701,64 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     }
   }
 
-  const reportPolicyBlock = async (prompt, block) => {
-    const taskMatch = /ticket\s+#?(\d+).*?project\s+(\d+)/i.exec(prompt)
+  const publishBlocker = async ({ prompt, taskRef, notice, pause = false }) => {
+    const sentenceTask = /ticket\s+#?(\d+).*?project\s+(\d+)/i.exec(prompt)
+    const jsonTask = /"id"\s*:\s*(\d+)[\s\S]{0,300}?"projectId"\s*:\s*(\d+)/i.exec(prompt)
+    const ticketId = Number(taskRef?.ticketId ?? sentenceTask?.[1] ?? jsonTask?.[1])
+    const projectId = Number(taskRef?.projectId ?? sentenceTask?.[2] ?? jsonTask?.[2])
     const channelMatch = /channel\s+(\d+)/i.exec(prompt)
     const parentMatch = /(?:parent_id|thread)\s+(\d+)/i.exec(prompt)
-    const command = block?.command || 'the requested external repository action'
-    const notice = `Action required: Codex reached ${command.includes('git push') ? 'the branch push step' : 'an external action'}, but the safety layer blocked \`${command}\` because private repository code cannot be sent to a remote without explicit approval for the destination and payload. Please explicitly authorize this exact push (repository remote + branch). Alex has paused the ticket and will not retry it automatically.`
+    const channelId = Number(channelMatch?.[1] ?? taskRef?.channelId)
 
-    if (channelMatch) {
-      await callMcpTool('post_message', {
-        channel_id: Number(channelMatch[1]),
-        ...(parentMatch ? { parent_id: Number(parentMatch[1]) } : {}),
-        content: notice,
-      })
+    let delivered = false
+    if (Number.isFinite(channelId)) {
+      try {
+        await callMcpTool('post_message', {
+          channel_id: channelId,
+          ...(parentMatch ? { parent_id: Number(parentMatch[1]) } : {}),
+          content: notice,
+        })
+        delivered = true
+      } catch (e) {
+        log('failed to post blocker in channel ' + channelId + ': ' + (e?.message || e))
+      }
+    }
+    if (!Number.isFinite(ticketId) || !Number.isFinite(projectId)) {
+      if (!Number.isFinite(channelId)) log('blocker has no source channel or ticket to update')
       return
     }
-    if (!taskMatch) { log('policy blocker has no source channel or ticket to update'); return }
 
-    const ticketId = Number(taskMatch[1])
-    const projectId = Number(taskMatch[2])
     const key = `${projectId}:${ticketId}`
-    blockedTasks.add(key)
-    persistReplay()
+    if (pause) { blockedTasks.add(key); persistReplay() }
     try {
       await callMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: notice })
+      delivered = true
       return
     } catch (e) {
-      log('comment_ticket unavailable for policy blocker; recording it on ticket #' + ticketId)
+      log('comment_ticket unavailable for blocker; recording it on ticket #' + ticketId)
     }
     const current = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
     const ticket = current.ticket ?? current.task ?? current
     const description = String(ticket.description || '')
-    if (!description.includes('[Agent action required]')) {
+    if (!description.includes(notice)) {
       await callMcpTool('update_ticket', {
         project_id: projectId,
         ticket_id: ticketId,
-        description: `${description}${description ? '\n\n' : ''}[Agent action required]\n${notice}`,
+        description: `${description}${description ? '\n\n' : ''}[Agent blocker]\n${notice}`,
       })
+      delivered = true
     }
+    if (!delivered) throw new Error('no blocker delivery path succeeded')
+  }
+
+  const reportPolicyBlock = async (prompt, taskRef, block) => {
+    const command = block?.command || 'the requested external repository action'
+    const payload = [block?.commit && `commit ${block.commit}`, block?.branch && `branch ${block.branch}`, block?.remote && `remote ${block.remote}`].filter(Boolean).join(', ')
+    const approval = block?.commit && block?.branch
+      ? `Reply with: “I explicitly authorize Alex to push commit ${block.commit} to the exact repository URL for ${block.remote || 'the configured remote'}, on branch ${block.branch}.”`
+      : 'Explicitly authorize the exact repository URL, commit, and branch in your reply.'
+    const notice = `Action required: Alex is blocked at \`${command}\`${payload ? ` (${payload})` : ''}. Codex requires confirmation before exporting private repository code. ${approval} The ticket is paused until that approval is recorded.`
+    return publishBlocker({ prompt, taskRef, notice, pause: true })
   }
 
   // Reconcile everything that may have arrived while disconnected. This spends no
@@ -802,7 +822,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
           const next = [...assigned].sort((a, b) => (priorityRank[a.priority] ?? 9) - (priorityRank[b.priority] ?? 9) || String(a.updatedAt || '').localeCompare(String(b.updatedAt || '')))[0]
           log('backlog reconciliation found ' + assigned.length + ' assigned task(s); queueing only ticket #' + next.id)
           const activityChannel = await projectStatusChannel(next.projectId)
-          void drain('full', `Backlog reconciliation verified this open ticket is assigned to YOU: ${JSON.stringify(next)}. Process this ONE ticket only. This is backlog-only work with NO source message or requester thread: do NOT post_message and do not announce progress or completion in any channel. Call get_ticket, use list_task_types and update_ticket to move it active, complete and verify the work, open the PR, then update the ticket with evidence and move it to done when appropriate.`, activityChannel == null ? [] : [activityChannel])
+          void drain('full', `Backlog reconciliation verified this open ticket is assigned to YOU: ${JSON.stringify(next)}. Process this ONE ticket only. This is backlog-only work with NO source message or requester thread: do NOT post_message and do not announce progress or completion in any channel. Call get_ticket, use list_task_types and update_ticket to move it active, complete and verify the work, open the PR, then update the ticket with evidence and move it to done when appropriate.`, activityChannel == null ? [] : [activityChannel], { projectId: next.projectId, ticketId: next.id, channelId: activityChannel })
         }
       }
       const inboxSignature = JSON.stringify(mentionActivity.slice(-20)).slice(0, 4000)
@@ -821,14 +841,16 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   const RANK = { fast: 0, intro: 1, coord: 2, sweep: 2, full: 3 }
   const baseFor = (kind) => kind === 'intro' ? INTRO : kind === 'full' ? fullPrompt : (kind === 'coord' || kind === 'sweep') ? COORDINATE : fastPrompt
 
-  async function drain(kind, context, targetChannels = []) {
+  async function drain(kind, context, targetChannels = [], taskRef = null) {
     const laneName = kind === 'full' ? 'work' : 'reply'
     const lane = lanes[laneName]
     if (context) lane.pending.push(context)
+    if (taskRef) lane.taskRefs.push(taskRef)
     for (const channelId of targetChannels) if (Number.isFinite(Number(channelId))) lane.targets.add(Number(channelId))
     if (lane.busy) { lane.queued = (RANK[kind] ?? 0) >= (RANK[lane.queued] ?? 0) ? kind : lane.queued; log(laneName + ' lane busy — queued a ' + kind + ' follow-up cycle'); return }
     lane.busy = true
     const ctx = lane.pending.splice(0)
+    const activeTaskRef = lane.taskRefs.splice(0)[0] || null
     const targets = [...lane.targets]
     lane.targets.clear()
     laneStatusTargets[laneName] = new Set(targets)
@@ -849,13 +871,27 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const result = await runners[laneName].runCycle(prompt, useModel)
       if (agent === 'codex' && result?.subtype === 'blocked' && result?.policyBlock) {
         log('WORK_CYCLE_BLOCKED authorization required; pausing this ticket and publishing an action-required notice')
-        try { await reportPolicyBlock(prompt, result.policyBlock) }
+        try { await reportPolicyBlock(prompt, activeTaskRef, result.policyBlock) }
         catch (e) { log('failed to publish policy blocker: ' + (e?.message || e)) }
         return
       }
+      if (kind === 'full' && ['timeout', 'spawn-failed', 'error'].includes(result?.subtype)) {
+        const notice = `Alex is blocked: the coding cycle ended with ${result.subtype}. No completion is being claimed and the ticket remains open for retry.`
+        log('WORK_CYCLE_BLOCKED ' + result.subtype + '; publishing blocker')
+        try { await publishBlocker({ prompt, taskRef: activeTaskRef, notice }) }
+        catch (e) { log('failed to publish cycle blocker: ' + (e?.message || e)) }
+        return
+      }
+      if (kind !== 'full' && result?.mcpErrors?.length) {
+        const notice = `Alex is blocked by failed OpenVisio actions: ${result.mcpErrors.join(', ')}. No success is being claimed; the item needs retry or intervention.`
+        log('COORDINATION_CYCLE_BLOCKED failed MCP calls; publishing blocker')
+        try { await publishBlocker({ prompt, taskRef: activeTaskRef, notice }) }
+        catch (e) { log('failed to publish coordination blocker: ' + (e?.message || e)) }
+        return
+      }
       // Model prose never proves success or a blocker. Full cycles must produce
       // runtime-observed ticket reads, repository evidence, and ticket updates.
-      const ticketCycle = /ticket\s+#?\d+.*?project\s+\d+/i.test(prompt)
+      const ticketCycle = !!activeTaskRef || /ticket\s+#?\d+.*?project\s+\d+/i.test(prompt)
       const incomplete = !result?.didRepoMutation || (ticketCycle && (!result?.didMcpTaskRead || !result?.didMcpTaskUpdate)) || result?.mcpErrors?.length
       if (agent === 'codex' && kind === 'full' && result?.subtype === 'ok' && incomplete) {
         const missing = [ticketCycle && !result.didMcpTaskRead && 'read the ticket through get_ticket/list_tasks', !result.didRepoMutation && 'perform and verify the repository change', ticketCycle && !result.didMcpTaskUpdate && 'update the ticket through update_ticket'].filter(Boolean)
@@ -864,8 +900,19 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         const recovery = await runners.work.runCycle(`The assigned task is NOT complete. Missing runtime evidence: ${missing.join('; ')}. Do not post an acknowledgement or claim success. Resume now. Use get_ticket/list_tasks and list_task_types, perform and verify the repository work, commit and push an agent/* branch, open the PR, and call update_ticket with the correct board column. Post only when the original context supplies a source thread.`, codeModel)
         const recoveryIncomplete = recovery?.subtype !== 'ok' || !recovery?.didRepoMutation || (ticketCycle && (!recovery?.didMcpTaskRead || !recovery?.didMcpTaskUpdate)) || recovery?.mcpErrors?.length
         if (recoveryIncomplete) {
-          const taskMatch = /ticket\s+#?(\d+).*?project\s+(\d+)/i.exec(prompt)
-          if (taskMatch) seenTasks.delete(`${taskMatch[2]}:${taskMatch[1]}`)
+          if (recovery?.subtype === 'blocked' && recovery?.policyBlock) {
+            try { await reportPolicyBlock(prompt, activeTaskRef, recovery.policyBlock) }
+            catch (e) { log('failed to publish recovery policy blocker: ' + (e?.message || e)) }
+          } else {
+            const notice = `Alex is blocked after one recovery attempt. Missing required evidence: ${missing.join('; ')}. The ticket remains open and no completion is being claimed.`
+            try { await publishBlocker({ prompt, taskRef: activeTaskRef, notice }) }
+            catch (e) { log('failed to publish recovery blocker: ' + (e?.message || e)) }
+          }
+          if (activeTaskRef) seenTasks.delete(`${activeTaskRef.projectId}:${activeTaskRef.ticketId}`)
+          else {
+            const taskMatch = /ticket\s+#?(\d+).*?project\s+(\d+)/i.exec(prompt)
+            if (taskMatch) seenTasks.delete(`${taskMatch[2]}:${taskMatch[1]}`)
+          }
           lastTaskSignature = ''
           log('WORK_CYCLE_FAILED evidence gate still incomplete after one recovery; ticket retained for retry')
         }
@@ -958,7 +1005,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       log(kind + ' verified ticket #' + ticketId + ' “' + title + '” -> ' + cycleKind + ' lane')
       const activityChannel = await projectStatusChannel(projectId)
       if (activityChannel != null) sendStatus(activityChannel, 'thinking')
-      void drain(cycleKind, `Authoritative get_ticket verification confirms ticket #${ticketId} in project ${projectId} is open and assigned to YOU: ${JSON.stringify({ id: ticketId, projectId, title, description: ticket.description, priority: ticket.priority, typeId: ticket.type_id ?? ticket.typeId })}. This assignment has no source channel: do not post_message. Use list_task_types and update_ticket to move it active, complete and verify the work, open the PR when applicable, then update/move the ticket with evidence. Never announce it in a channel.`, activityChannel == null ? [] : [activityChannel])
+      void drain(cycleKind, `Authoritative get_ticket verification confirms ticket #${ticketId} in project ${projectId} is open and assigned to YOU: ${JSON.stringify({ id: ticketId, projectId, title, description: ticket.description, priority: ticket.priority, typeId: ticket.type_id ?? ticket.typeId })}. This assignment has no source channel: do not post_message. Use list_task_types and update_ticket to move it active, complete and verify the work, open the PR when applicable, then update/move the ticket with evidence. Never announce it in a channel.`, activityChannel == null ? [] : [activityChannel], { projectId, ticketId, channelId: activityChannel })
     } catch (e) {
       log(kind + ' ticket verification failed for #' + ticketId + ': ' + (e?.message || e))
     }