openvisio-agent 0.17.0 → 0.17.2

package/package.json

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

@@ -29,12 +29,22 @@ const assertions = [
   ['task:assigned is handled', watcher.includes("k === 'task:assigned'")],
   ['task signals are verified with get_ticket', watcher.includes("callMcpTool('get_ticket'")],
   ['two internal lanes exist', watcher.includes('work: createCycleRunner') && watcher.includes('reply: createCycleRunner')],
+  ['work and reply activity targets are isolated', watcher.includes("laneStatusTargets = { work: new Set(), reply: new Set() }") && watcher.includes("emitLaneStatus('work', 'typing')") && watcher.includes("emitLaneStatus('reply', 'typing')")],
+  ['assigned task activity resolves a project channel', watcher.includes("callMcpTool('list_channels'") && watcher.includes('projectStatusChannel(projectId)')],
+  ['working heartbeat is battery-conscious', watcher.includes("emitLaneStatus(laneName, 'working'), 20_000")],
   ['activity uses REST endpoint', watcher.includes('agentStateRequest(')],
   ['websocket client cannot emit legacy agent_status', !websocket.includes('agent_status')],
   ['frontend consumes thinking event', activityHook.includes("'channel:agent:thinking'")],
   ['frontend consumes working event', activityHook.includes("'channel:agent:working'")],
   ['frontend consumes typing event', activityHook.includes("'channel:agent:typing'")],
+  ['frontend activity TTL distinguishes work from typing', activityHook.includes('thinking: 6_000') && activityHook.includes('typing: 5_000') && activityHook.includes('working: 30_000')],
   ['completion has an evidence failure gate', watcher.includes('WORK_CYCLE_FAILED')],
+  ['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, 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

@@ -48,6 +48,17 @@ export function agentStateRequest(backend, channelId, state, apiKey, identifier)
   }
 }
 
+export function codexPolicyBlock(value) {
+  const text = String(value || '')
+  if (!/rejected due to unacceptable risk|action was rejected due to unacceptable risk|explicitly approves? the action/i.test(text)) return null
+  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.'
+  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
 // that the request was addressed to it. Reject a later-agent hand-off before a
 // model starts, while keeping explicitly shared requests addressed to both.

package/src/watch.mjs

@@ -10,7 +10,7 @@ import { homedir } from 'node:os'
 import { join, dirname } from 'node:path'
 import { OV_DIR, DEFAULT_WORKSPACE, readConfig, writeJson, configPath, onPath, fail, ok, info, slugify, stripSlash, chmodSafe } from './lib.mjs'
 import { connectAgentWs, assertWebSocket } from './ws.mjs'
-import { agentStateRequest, requestTargetsLaterAgent, taskAgentId, taskFromEvent, taskIsCompleted } from './events.mjs'
+import { agentStateRequest, codexPolicyBlock, requestTargetsLaterAgent, taskAgentId, taskFromEvent, taskIsCompleted } from './events.mjs'
 
 // Behaviour prompts. The openvisio-team MCP bridge requires the agent's
 // credentials as ARGUMENTS on every tool call — those are injected at runtime by
@@ -345,7 +345,8 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
         ...(m ? ['--model', m] : []),
         ...(mcpOverride ? ['-c', mcpOverride] : []),
         full]
-      let child = null, done = false, didCode = false, didRepoMutation = false, didMessage = false, outputText = '', jsonlBuffer = ''
+      let child = null, done = false, didCode = false, didRepoMutation = false, didMessage = false, outputText = '', jsonlBuffer = '', stderrBuffer = ''
+      let policyBlock = null
       const mcpCalls = new Set(), mcpErrors = new Set()
       let didMcpTaskRead = false, didMcpTaskUpdate = false
       const finish = (o) => {
@@ -354,7 +355,12 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
         clearTimeout(timer)
         const calls = [...mcpCalls]
         log('codex MCP calls: ' + (calls.length ? calls.join(', ') : 'none') + (mcpErrors.size ? ' (failed: ' + [...mcpErrors].join(', ') + ')' : ''))
-        resolve({ ...o, didCode, didRepoMutation, didMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, mcpErrors: [...mcpErrors], outputText })
+        resolve({ ...o, didCode, didRepoMutation, didMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, mcpErrors: [...mcpErrors], outputText, policyBlock })
+      }
+      const inspectDiagnostic = (value) => {
+        const s = String(value || '')
+        stderrBuffer = (stderrBuffer + s).slice(-24_000)
+        policyBlock = codexPolicyBlock(stderrBuffer) || policyBlock
       }
       const inspectLine = (line) => {
         const s = line.trim()
@@ -387,18 +393,27 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
       try {
         // Always inspect Codex JSONL so a successful process exit cannot be
         // mistaken for completed work. Keep it out of normal logs unless debug.
-        child = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'inherit'] })
+        child = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] })
         if (child.stdout) child.stdout.on('data', (d) => {
           jsonlBuffer += String(d)
           const lines = jsonlBuffer.split('\n')
           jsonlBuffer = lines.pop() ?? ''
           for (const line of lines) inspectLine(line)
         })
+        if (child.stderr) child.stderr.on('data', (d) => {
+          inspectDiagnostic(d)
+          process.stderr.write(d)
+        })
       } catch (e) {
         log('codex spawn failed: ' + (e && e.message ? e.message : e) + ' — is Codex installed and signed in? (`npm i -g @openai/codex`, then `codex login`)')
         return finish({ type: 'result', subtype: 'spawn-failed' })
       }
-      child.on('close', (code) => { inspectLine(jsonlBuffer); jsonlBuffer = ''; log('codex cycle done (' + (code === 0 ? 'ok' : 'exit ' + code) + ')'); finish({ type: 'result', subtype: code === 0 ? 'ok' : 'error' }) })
+      child.on('close', (code) => {
+        inspectLine(jsonlBuffer); jsonlBuffer = ''; inspectDiagnostic('')
+        const subtype = policyBlock ? 'blocked' : code === 0 ? 'ok' : 'error'
+        log('codex cycle done (' + (subtype === 'blocked' ? 'BLOCKED: user authorization required' : subtype === 'ok' ? 'ok' : 'exit ' + code) + ')')
+        finish({ type: 'result', subtype })
+      })
       child.on('error', (e) => { log('codex error: ' + (e && e.message ? e.message : e)); finish({ type: 'result', subtype: 'error' }) })
     })
   }
@@ -532,10 +547,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   const log = (m) => process.stdout.write('[ws ' + new Date().toISOString() + '] ' + m + '\n')
   let handle = null
   const statusBackoff = new Map()
-  // Channels the agent is actively working in this cycle — drives the live
-  // Agent state is an authenticated REST call. The backend then fans out the
-  // documented channel:agent:* event to the app; it is never a WS client frame.
-  const statusTargets = new Set()
+  // Activity belongs to a lane. Keeping work/reply targets separate prevents a
+  // quick reply from overwriting or clearing a long coding cycle's status.
+  const laneStatusTargets = { work: new Set(), reply: new Set() }
   const sendStatus = (channelId, state) => {
     if (!backend || !['thinking', 'working', 'typing'].includes(state)) return
     const key = Number(channelId)
@@ -552,7 +566,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       log('agent state request failed: ' + (e?.message || e) + '; backing off 30s')
     })
   }
-  const emitStatus = (state) => { for (const c of statusTargets) sendStatus(c, state) }
+  const emitLaneStatus = (lane, state) => { for (const c of laneStatusTargets[lane]) sendStatus(c, state) }
   const canCode = !!workdir
   // The Mastra bridge authenticates per-CALL: every openvisio-team tool needs
   // agent_identifier + agent_api_key as arguments. Hand them over up front.
@@ -563,14 +577,12 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   const runnerOptions = {
     claude, agent, mcpUrl, mcpHeaders: { 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier },
     cfgKey: identifier, mcpConfig, workdir, log, debug, model, systemPrompt,
-    // The moment the agent calls post_message it is about to speak → "typing".
-    onTool: (name) => { if (/post_message/.test(name)) emitStatus('typing') },
   }
   // One watcher and one WS subscription, but two independent model lanes. This
   // avoids duplicate event delivery while mentions can be answered during code.
   const runners = {
-    work: createCycleRunner(runnerOptions),
-    reply: createCycleRunner({ ...runnerOptions, cfgKey: identifier + '-reply' }),
+    work: createCycleRunner({ ...runnerOptions, onTool: (name) => { if (/post_message/.test(name)) emitLaneStatus('work', 'typing') } }),
+    reply: createCycleRunner({ ...runnerOptions, cfgKey: identifier + '-reply', onTool: (name) => { if (/post_message/.test(name)) emitLaneStatus('reply', 'typing') } }),
   }
   const fullPrompt = canCode ? CODE_FULL : CYCLE
   const fastPrompt = canCode ? CODE_FAST : CYCLE_FAST
@@ -581,8 +593,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   let liteModel = chatModel || model
 
   const lanes = {
-    work: { busy: false, queued: null, pending: [] },
-    reply: { busy: false, queued: null, pending: [] },
+    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
@@ -596,9 +608,14 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   try { replayState = JSON.parse(readFileSync(replayPath, 'utf8')) } catch { /* first run */ }
   const seenMentions = new Set(Array.isArray(replayState.seenMentions) ? replayState.seenMentions : [])
   const seenActivities = new Set(Array.isArray(replayState.seenActivities) ? replayState.seenActivities : [])
+  // A policy-blocked task stays paused across reconnects. It is released only
+  // after the ticket itself carries explicit authorization or is completed/
+  // unassigned. This prevents a 30-minute reconciliation retry from repeatedly
+  // attempting the same rejected egress action.
+  const blockedTasks = new Set(Array.isArray(replayState.blockedTasks) ? replayState.blockedTasks : [])
   const trimSeen = (set) => { while (set.size > 500) set.delete(set.values().next().value) }
   const persistReplay = () => {
-    try { writeJson(replayPath, { seenMentions: [...seenMentions], seenActivities: [...seenActivities] }, true) } catch { /* best-effort */ }
+    try { writeJson(replayPath, { seenMentions: [...seenMentions], seenActivities: [...seenActivities], blockedTasks: [...blockedTasks] }, true) } catch { /* best-effort */ }
   }
   // Context lines from the events themselves (the WS payload already carries the
   // channel + message / task), so the agent acts on THEM directly instead of
@@ -633,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.0' } } }, 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') || ''
@@ -663,6 +680,87 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     try { return JSON.parse(text) } catch { return { text } }
   }
 
+  const statusChannelCache = new Map()
+  const projectStatusChannel = async (projectId) => {
+    const key = Number(projectId)
+    const cached = statusChannelCache.get(key)
+    if (cached && cached.expiresAt > Date.now()) return cached.channelId
+    try {
+      const data = toolData(await callMcpTool('list_channels', { project_id: key }))
+      const channels = Array.isArray(data.channels) ? data.channels : Array.isArray(data.data?.channels) ? data.data.channels : Array.isArray(data.data) ? data.data : Array.isArray(data.items) ? data.items : []
+      const usable = channels.filter((c) => Number.isFinite(Number(c.id)))
+      const preferred = usable.find((c) => /^(?:general|team|project|dev|development)$/i.test(String(c.name || '').trim())) || usable[0]
+      const channelId = preferred ? Number(preferred.id) : null
+      statusChannelCache.set(key, { channelId, expiresAt: Date.now() + 5 * 60_000 })
+      if (channelId == null) log('no channel available for project ' + key + '; task activity cannot be displayed')
+      return channelId
+    } catch (e) {
+      statusChannelCache.set(key, { channelId: null, expiresAt: Date.now() + 30_000 })
+      log('cannot resolve activity channel for project ' + key + ': ' + (e?.message || e))
+      return null
+    }
+  }
+
+  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 channelId = Number(channelMatch?.[1] ?? taskRef?.channelId)
+
+    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
+    }
+
+    const key = `${projectId}:${ticketId}`
+    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 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(notice)) {
+      await callMcpTool('update_ticket', {
+        project_id: projectId,
+        ticket_id: ticketId,
+        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
   // model tokens unless the tools actually report pending work.
   const reconcileBacklog = async () => {
@@ -689,6 +787,14 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
           const taskAgentId = Number(task.agent_id ?? task.agentId ?? task.agent?.id)
           const taskIdent = String(task.agent?.identifier ?? task.agent?.slug ?? '')
           if (!taskIsCompleted(task, doneIds) && (taskAgentId === Number(self.id) || taskIdent === identifier)) {
+            const taskKey = `${project.id}:${task.id}`
+            if (blockedTasks.has(taskKey)) {
+              const approvalText = [task.title, task.description].filter(Boolean).join(' ')
+              if (/\b(?:i\s+)?(?:explicitly\s+)?(?:approve|authorize)\b[\s\S]{0,240}\b(?:git\s+push|push(?:ing)?\s+(?:the\s+)?(?:branch|code)|github|remote)\b/i.test(approvalText)) {
+                blockedTasks.delete(taskKey); seenTasks.delete(taskKey); persistReplay()
+                log('backlog ticket #' + task.id + ' now contains explicit push authorization — resuming')
+              } else continue
+            }
             assigned.push({ id: task.id, projectId: project.id, project: project.name, title: task.title, priority: task.priority, typeId: task.type_id ?? task.typeId, updatedAt: task.updated_at ?? task.updatedAt })
           }
         }
@@ -715,7 +821,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
           const priorityRank = { critical: 0, high: 1, medium: 2, low: 3 }
           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)
-          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.`)
+          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], { projectId: next.projectId, ticketId: next.id, channelId: activityChannel })
         }
       }
       const inboxSignature = JSON.stringify(mentionActivity.slice(-20)).slice(0, 4000)
@@ -734,13 +841,19 @@ 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) {
+  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)
     // credNote + charter live in the cached system prompt now — the per-cycle
     // message is just the event context + the small base instruction.
     const prompt = (ctx.length ? ctx.join('\n') + '\n\n' : '') + baseFor(kind)
@@ -750,14 +863,35 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     log('running ' + kind + ' cycle…' + (ctx.length ? ' (' + ctx.length + ' event' + (ctx.length === 1 ? '' : 's') + ')' : '') + (useModel ? ' [' + useModel + ']' : ''))
     // Live status: "working" now + a heartbeat so the UI (and its TTL) stays lit
     // through a long cycle; onTool flips it to "typing" when post_message fires.
-    const targets = [...statusTargets]
-    emitStatus('working')
-    const heartbeat = targets.length ? setInterval(() => emitStatus('working'), 9000) : null
+    emitLaneStatus(laneName, 'working')
+    // Backend activity TTL is refreshed well before expiry, but only once every
+    // 20 seconds so long coding runs do not create needless network/battery load.
+    const heartbeat = targets.length ? setInterval(() => emitLaneStatus(laneName, 'working'), 20_000) : null
     try {
       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, 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)
@@ -766,15 +900,26 @@ 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')
         }
       }
     } finally {
       if (heartbeat) clearInterval(heartbeat)
-      for (const c of targets) statusTargets.delete(c)
+      laneStatusTargets[laneName].clear()
       lane.busy = false
       if (lane.queued || lane.pending.length) { const next = lane.queued || (laneName === 'work' ? 'full' : 'fast'); lane.queued = null; void drain(next) }
     }
@@ -840,15 +985,27 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const assignedIdentifier = String(ticket.agent?.identifier ?? ticket.assigned_agent?.identifier ?? '')
       const belongsToSelf = (selfAgentId != null && assignedId === selfAgentId) || assignedIdentifier === identifier
       const key = `${projectId}:${ticketId}`
-      if (!belongsToSelf) { seenTasks.delete(key); log(kind + ' ticket #' + ticketId + ' is not assigned to this agent — ignored'); return }
-      if (taskIsCompleted(ticket)) { seenTasks.add(key); log(kind + ' ticket #' + ticketId + ' is already complete — ignored'); return }
+      if (!belongsToSelf) { blockedTasks.delete(key); persistReplay(); seenTasks.delete(key); log(kind + ' ticket #' + ticketId + ' is not assigned to this agent — ignored'); return }
+      if (taskIsCompleted(ticket)) { blockedTasks.delete(key); persistReplay(); seenTasks.add(key); log(kind + ' ticket #' + ticketId + ' is already complete — ignored'); return }
+      if (blockedTasks.has(key)) {
+        const approvalText = [ticket.title, ticket.description].filter(Boolean).join(' ')
+        if (/\b(?:i\s+)?(?:explicitly\s+)?(?:approve|authorize)\b[\s\S]{0,240}\b(?:git\s+push|push(?:ing)?\s+(?:the\s+)?(?:branch|code)|github|remote)\b/i.test(approvalText)) {
+          blockedTasks.delete(key); seenTasks.delete(key); persistReplay()
+          log(kind + ' ticket #' + ticketId + ' contains explicit push authorization — resuming')
+        } else {
+          log(kind + ' ticket #' + ticketId + ' is paused for explicit repository push authorization — ignored')
+          return
+        }
+      }
       if (seenTasks.has(key)) { log(kind + ' ticket #' + ticketId + ' already queued/active — ignored'); return }
       seenTasks.add(key); trimSeen(seenTasks)
       const title = String(ticket.title || hinted.title || '')
       const taskText = [title, ticket.description, ticket.type, ticket.kind].filter(Boolean).join(' ')
       const cycleKind = canCode && !coordinationOnly(taskText) ? 'full' : 'coord'
       log(kind + ' verified ticket #' + ticketId + ' “' + title + '” -> ' + cycleKind + ' lane')
-      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.`)
+      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], { projectId, ticketId, channelId: activityChannel })
     } catch (e) {
       log(kind + ' ticket verification failed for #' + ticketId + ': ' + (e?.message || e))
     }
@@ -901,9 +1058,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         return
       }
       log('agent:mention in channel ' + (cid != null ? cid : '?') + (threadRoot != null ? ' (thread ' + threadRoot + ')' : ''))
-      // Light up the live status the instant we pick this up (thinking → the cycle
-      // takes it to working → typing → done).
-      if (cid != null) { statusTargets.add(cid); sendStatus(cid, 'thinking') }
+      // Light up the live status the instant we pick this up; drain owns the
+      // subsequent working/typing heartbeat for its lane.
+      if (cid != null) sendStatus(cid, 'thinking')
       const codingMention = canCode && needsCode(text)
       const ctx = cid != null
         ? `You were @mentioned in OpenVisio channel ${cid}${who ? ` by "${who}"` : ''}: "${text}". This mention is FOR YOU. ${codingMention ? 'This is repository work: complete the coding flow first, then send' : 'Send'} EXACTLY ONE reply with post_message: arguments: channel_id ${cid}${threadRoot != null ? `, parent_id ${threadRoot} (reply IN THAT THREAD, do not start a new top-level message)` : ''}, plus agent_identifier + agent_api_key from the AUTH line above, and a 1-3 sentence reply. Compose the whole answer, then post it ONCE. Do not post a first reply and then a revised version. FIRST read the recent messages in this thread: if you already answered this, or another agent was the one addressed, do NOT post at all. Be sure of your answer before sending.${who ? ` To @mention them back, write their EXACT full name "@${who}". A mention only links when the name matches exactly.` : ''} You ALREADY have the message here. Do not poll_inbox, and after your single reply, STOP.`
@@ -912,9 +1069,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         const ack = cid != null
           ? `You were asked for repository work in channel ${cid}${threadRoot != null ? `, thread ${threadRoot}` : ''}. The dedicated work lane has accepted it. Post exactly one short reply with post_message in that same thread saying you have picked it up and will return there with the verified result. Include agent_identifier + agent_api_key. Do not inspect or edit code in this reply lane.`
           : undefined
-        void drain('coord', ack)
-        void drain('full', ctx)
-      } else void drain('fast', ctx)
+        void drain('coord', ack, cid == null ? [] : [cid])
+        void drain('full', ctx, cid == null ? [] : [cid])
+      } else void drain('fast', ctx, cid == null ? [] : [cid])
     } else if (k === 'error') {
       const detail = raw && (raw.message || raw.error || raw.reason || raw.code || raw.d?.message || raw.d?.error)
       log('error event: ' + (detail ? String(detail) : JSON.stringify(raw)).slice(0, 220))