openvisio-agent 0.18.6 → 0.18.7

package/README.md

@@ -50,7 +50,7 @@ npx -y openvisio-agent@latest connect --backend https://api.your-org.example/dev
 - `--ws <wss-url>` — the org's API-Gateway WebSocket base (the same value the frontend uses as `NEXT_PUBLIC_BACKEND_WS_URL`).
 - `--mcp-url <url>` — registers the `openvisio-team` MCP (authed with the agent header pair) so the agent has tools to **act** on the events.
 
-Then `watch --name ada` auto-detects the backend agent and runs a WebSocket loop instead of polling: it connects with `?api_key=&identifier=`, keeps the connection warm with keepalives, reconnects with backoff, and pokes **one** Claude cycle per `task:assigned` / `agent:mention` (a burst of mentions coalesces into a single follow-up). Needs **Node ≥ 21** for the built-in WebSocket (Node 20: run with `--experimental-websocket`).
+Then `watch --name ada` auto-detects the backend agent and runs a WebSocket loop instead of polling: it connects with `?api_key=&identifier=`, keeps the connection warm with keepalives, reconnects with backoff, and starts one work cycle per `task:assigned` / `agent:mention` (a burst of mentions coalesces into a follow-up). A work cycle can contain many assistant, tool, and message actions; emitting a progress message does not end it. Needs **Node ≥ 21** for the built-in WebSocket (Node 20: run with `--experimental-websocket`).
 
 ### `watch --name <agent>`
 
@@ -62,7 +62,7 @@ The backend MCP may be stateful or stateless. A successful initialize response w
 
 Codex BYO agents follow the repository's normative runtime specification in `docs/CODEX_BYO_AGENT_SPEC.md`: one WebSocket identity, independent Sol reply/work lanes, authoritative `get_ticket` verification for assignments, REST-backed in-app activity, persistent replay suppression, and runtime evidence gates before completion. Maintainers must run `npm run certify` before publishing.
 
-An `agent:mention` event only wakes the watcher; it does not grant ownership of the conversation. The actual source message is checked before any model starts. Messages redirected to another agent and unaddressed agent chatter stay silent, while a direct stand-down cancels queued/running work for that thread. Accepted coding work uses the activity indicator instead of a generic pickup message, then returns one verified result or concrete blocker in the source thread.
+An `agent:mention` event only wakes the watcher; it does not grant ownership of the conversation. The actual source message is checked before any model starts. Messages redirected to another agent and unaddressed agent chatter stay silent, while a direct stand-down cancels queued/running work for that thread. Accepted coding work uses the activity indicator instead of a generic pickup message. Claude and OpenCode may add one concrete progress update after work begins, but must continue and post a distinct verified result or blocker afterward; Codex keeps cancellation-safe delivery watcher-owned and renders the verified final answer once.
 
 Ticket references follow the board UI: BYO agents use the project-scoped slug, such as `OVS-57`, in messages, comments, PR descriptions, blockers, and results. Numeric `project_id` and `ticket_id` values remain internal MCP arguments and are never used as human-facing ticket names. If an older backend omits the slug, the agent uses the ticket title rather than inventing one.
 

package/package.json

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

@@ -47,7 +47,7 @@ const assertions = [
   ['completion requires review/done state and PR evidence', watcher.includes('buildTaskCompletionReport') && watcher.includes('completion report deferred')],
   ['completion delivery survives reconnect and deduplicates', watcher.includes('pendingCompletionReports: [...pendingCompletionReports]') && watcher.includes('reportedCompletions: [...reportedCompletions]') && watcher.includes('reportedCompletions.has(report.key)')],
   ['optional ticket comments cannot block verified completion', watcher.includes("callOptionalMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: report.content })") && watcher.includes('comment_ticket is not exposed; completing ticket') && watcher.includes('reportedTaskComments: [...reportedTaskComments]') && watcher.includes('reportedTaskComments.has(report.key)')],
-  ['ticket comments cannot masquerade as channel completion', watcher.includes('didChannelMessage') && watcher.includes("mcpCalls.includes('post_message')")],
+  ['ticket comments cannot masquerade as channel completion', events.includes("didChannelMessage: completed && mcpTool === 'post_message'") && watcher.includes('result.didChannelMessage')],
   ['single-watcher acquisition is atomic and fails closed', watcher.includes("openSync(lockPath, 'wx')") && watcher.includes('Could not acquire the single-watcher lock')],
   ['websocket and activity mention delivery share a replay guard', watcher.includes('markMentionHandled(activityMessage, activityChannelId)') && watcher.includes('markMentionHandled(msg, cid)') && watcher.includes('recentMentionSignatures')],
   ['reconciled mentions reuse the guarded websocket delivery path', watcher.includes("onEvent('agent:mention'") && watcher.includes('_mentionAlreadyMarked: true')],
@@ -87,7 +87,9 @@ const assertions = [
   ['OpenCode identities use isolated configs outside the code workspace', watcher.includes('opencodeRuntimeLayout({ cfgKey, workdir })') && watcher.includes("'--dir', workspace") && watcher.includes('OPENCODE_CONFIG: opencodeConfigPath') && watcher.includes('OPENCODE_CONFIG_CONTENT: JSON.stringify(opencodeConfig)')],
   ['OpenCode backend prompts forbid relay and resource-discovery tools', watcher.includes('BACKEND MCP RULE') && watcher.includes('get_marching_orders, poll_inbox, get_resource, list_mcp_resources, list_mcp_resource_templates')],
   ['OpenCode tool failures retain sanitized diagnostics', events.includes('toolError: toolError.replace') && watcher.includes("opencode tool '") && watcher.includes("split(redactKey).join('[redacted]')")],
-  ['OpenCode acknowledgements cannot satisfy coding completion', watcher.includes("agent === 'codex' || agent === 'opencode'") && watcher.includes('releaseTaskForRetry(activeTaskRef, prompt)')],
+  ['all runtime acknowledgements cannot satisfy coding completion', watcher.includes('missingRuntimeWorkEvidence(result') && watcher.includes('claudeEventEvidence(o, turnToolUses)') && watcher.includes('releaseTaskForRetry(activeTaskRef, prompt)')],
+  ['Codex prose cannot masquerade as repository evidence', watcher.includes('codexEventEvidence(event)') && events.includes("item.type === 'agent_message'") && events.includes("event.type === 'item.completed'")],
+  ['coding recovery retains source context and requires a final result', watcher.includes('ORIGINAL REQUEST AND ROUTING CONTEXT') && events.includes('resultMessageRequired && !result?.didResultMessage') && events.includes("outputText: second?.outputText || first?.outputText || ''")],
   ['backend MCP accepts stateless initialize responses', mcpHttp.includes("mode = () => !initialized ? 'uninitialized' : sessionId ? 'stateful' : 'stateless'") && !watcher.includes('MCP initialize returned no session id')],
   ['MCP initialize is shared across concurrent startup probes', mcpHttp.includes('if (initializePromise) return initializePromise')],
   ['stateless tool errors do not cause initialize loops', mcpHttp.includes('if (hadSession && !retried')],

package/src/events.mjs

@@ -56,7 +56,21 @@ export function taskIsAwaitingReview(task, reviewTypeIds = new Set()) {
   return /\b(?:review|test|testing|qa|quality\s+assurance|verification|approval)\b/i.test(state)
 }
 
-export function buildTaskCompletionReport(task, { projectId, fallbackText = '' } = {}) {
+function personDisplayName(person) {
+  if (!person || typeof person !== 'object') return ''
+  return (`${person.first_name || person.firstName || ''} ${person.last_name || person.lastName || ''}`.trim() || person.name || '').trim()
+}
+
+/** The human responsible for a BYO agent is the person who added it, not the
+ * creator of whichever ticket it happens to complete. Backend deployments have
+ * exposed that relationship under both association and transport-style names. */
+export function agentAddedByName(agent) {
+  if (!agent || typeof agent !== 'object') return ''
+  const addedBy = agent.agentCreator || agent.agent_creator || agent.createdByUser || agent.created_by_user || agent.owner || agent.user
+  return personDisplayName(addedBy)
+}
+
+export function buildTaskCompletionReport(task, { projectId, fallbackText = '', recipientName = '' } = {}) {
   if (!task || typeof task !== 'object' || task.id == null) return null
   if (!taskIsCompleted(task) && !taskIsAwaitingReview(task)) return null
 
@@ -64,8 +78,7 @@ export function buildTaskCompletionReport(task, { projectId, fallbackText = '' }
   const prUrl = /https:\/\/github\.com\/[^\s)\]}>]+\/pull\/\d+/i.exec(evidence)?.[0]?.replace(/[.,;:]+$/, '') || ''
   if (!prUrl) return null
 
-  const creator = task.creator || task.created_by_user || task.createdByUser || {}
-  const requester = (`${creator.first_name || creator.firstName || ''} ${creator.last_name || creator.lastName || ''}`.trim() || creator.name || '').trim()
+  const requester = String(recipientName || '').trim()
   const title = String(task.title || 'Untitled task').replace(/\s+/g, ' ').trim().slice(0, 180)
   const status = String(task.type?.name || task.task_type?.name || task.status || task.state || 'review').replace(/\s+/g, ' ').trim()
   const verification = /\bVerification:\s*([^\n]{1,180})/i.exec(evidence)?.[1]?.replace(/\s+/g, ' ').trim().replace(/[.]+$/, '') || ''
@@ -131,6 +144,131 @@ export function opencodeEventEvidence(event) {
   }
 }
 
+// Codex emits started/completed JSONL records for the same item. Trust only a
+// completed, non-failed record for mutation and MCP evidence. In particular,
+// words such as "apply_patch" inside an agent_message are just prose.
+export function codexEventEvidence(event) {
+  if (!event || typeof event !== 'object') return {}
+  const item = event.item ?? event
+  if (!item || typeof item !== 'object') return {}
+  if (item.type === 'agent_message') return { outputText: typeof item.text === 'string' ? item.text : '' }
+
+  const status = String(item.status ?? '').toLowerCase()
+  const completed = event.type === 'item.completed' || /^(?:completed|success|succeeded|ok)$/.test(status)
+  const failed = event.type === 'item.failed' || /(?:fail|error|denied|rejected)/.test(status) || item.error != null || Number(item.exit_code) > 0
+  const itemType = String(item.type ?? '')
+  if (/^(?:command_execution|file_change|apply_patch|shell_command|exec_command)$/.test(itemType)) {
+    const command = String(item.command ?? item.input?.command ?? item.input?.cmd ?? '')
+    return {
+      failed,
+      completed: completed && !failed,
+      didCode: completed && !failed,
+      didRepoMutation: completed && !failed && (/^(?:file_change|apply_patch)$/.test(itemType) || /\b(?:git\s+(?:commit|push)|gh\s+pr\s+create|openvisio-agent\s+push-pr-branch)\b/i.test(command)),
+    }
+  }
+  if (itemType !== 'mcp_tool_call') return {}
+
+  const rawTool = String(item.tool ?? item.name ?? item.method ?? 'unknown')
+  const prefixed = /^(?:mcp__)?openvisio(?:-team|_team)(?:__|[_.:/-])(.+)$/i.exec(rawTool)
+  const mcpTool = String(prefixed?.[1] ?? rawTool).replace(/[-.]/g, '_')
+  const succeeded = completed && !failed
+  return {
+    mcpTool,
+    failed,
+    completed: succeeded,
+    didCode: succeeded && /^(?:create_codebase_branch|create_codebase_commit|write_codebase_file|create_pull_request)$/.test(mcpTool),
+    didRepoMutation: succeeded && /^(?:create_codebase_branch|create_codebase_commit|write_codebase_file|create_pull_request)$/.test(mcpTool),
+    didMcpTaskRead: succeeded && /^(?:get_ticket|list_tasks|list_task_types)$/.test(mcpTool),
+    didMcpTaskUpdate: succeeded && mcpTool === 'update_ticket',
+    didMessage: succeeded && /^(?:post_message|comment_ticket)$/.test(mcpTool),
+    didChannelMessage: succeeded && mcpTool === 'post_message',
+  }
+}
+
+// Claude's stream-json protocol separates tool_use blocks from their later
+// tool_result blocks. Keep the pending uses supplied by the caller and reduce
+// only completed results to work evidence; announcing a tool call is not proof
+// that the action succeeded.
+export function claudeEventEvidence(event, pendingToolUses = new Map()) {
+  if (!event || typeof event !== 'object') return {}
+  const content = Array.isArray(event.message?.content) ? event.message.content : []
+  const output = []
+  const toolCalls = []
+  const toolResults = []
+
+  if (event.type === 'assistant') {
+    for (const block of content) {
+      if (block?.type === 'text' && typeof block.text === 'string' && block.text.trim()) output.push(block.text.trim())
+      if (block?.type !== 'tool_use' || !block.name) continue
+      const id = String(block.id ?? block.tool_use_id ?? '')
+      const use = { name: String(block.name), input: block.input && typeof block.input === 'object' ? block.input : {} }
+      if (id) pendingToolUses.set(id, use)
+      toolCalls.push(use.name)
+    }
+  }
+
+  if (event.type === 'user') {
+    for (const block of content) {
+      if (block?.type !== 'tool_result') continue
+      const id = String(block.tool_use_id ?? block.id ?? '')
+      const use = id ? pendingToolUses.get(id) : null
+      if (!use) continue
+      pendingToolUses.delete(id)
+      const failed = block.is_error === true
+      toolResults.push(opencodeEventEvidence({
+        type: 'tool_use',
+        part: {
+          type: 'tool',
+          tool: use.name,
+          state: {
+            status: failed ? 'error' : 'completed',
+            input: use.input,
+            ...(failed ? { error: block.content ?? 'Claude tool call failed' } : {}),
+          },
+        },
+      }))
+    }
+  }
+
+  return {
+    ...(output.length ? { outputText: output.join(' ') } : {}),
+    ...(toolCalls.length ? { toolCalls } : {}),
+    ...(toolResults.length ? { toolResults } : {}),
+  }
+}
+
+export function missingRuntimeWorkEvidence(result, { ticketCycle = false, resultMessageRequired = false } = {}) {
+  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',
+    resultMessageRequired && !result?.didResultMessage && 'post a final result after the repository work',
+  ].filter(Boolean)
+  if (result?.mcpErrors?.length) missing.push('resolve failed MCP calls: ' + result.mcpErrors.join(', '))
+  return missing
+}
+
+export function combineRuntimeWorkEvidence(first, second) {
+  return {
+    ...second,
+    didCode: !!first?.didCode || !!second?.didCode,
+    didRepoMutation: !!first?.didRepoMutation || !!second?.didRepoMutation,
+    didMessage: !!first?.didMessage || !!second?.didMessage,
+    didChannelMessage: !!first?.didChannelMessage || !!second?.didChannelMessage,
+    // A message in a continuation comes after repository work completed in the
+    // first turn, even when that continuation itself performs no new mutation.
+    didResultMessage: !!first?.didResultMessage || !!second?.didResultMessage || (!!first?.didRepoMutation && !!second?.didChannelMessage),
+    didMcpTaskRead: !!first?.didMcpTaskRead || !!second?.didMcpTaskRead,
+    didMcpTaskUpdate: !!first?.didMcpTaskUpdate || !!second?.didMcpTaskUpdate,
+    mcpCalls: [...new Set([...(first?.mcpCalls || []), ...(second?.mcpCalls || [])])],
+    // A focused continuation gets the chance to clear an earlier transient MCP
+    // failure. Only failures still present in the continuation remain blockers.
+    mcpErrors: second?.mcpErrors || [],
+    // Never deliver a stale promise together with a later verified result.
+    outputText: second?.outputText || first?.outputText || '',
+  }
+}
+
 export function agentStateRequest(backend, channelId, state, apiKey, identifier) {
   if (!['thinking', 'working', 'typing'].includes(state)) throw new Error('invalid agent state')
   const id = Number(channelId)

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, buildTaskCompletionReport, classifyConversationTarget, codexPolicyBlock, conversationNeedsCode, mentionDedupeKeys, normalizeRenderedMessageText, opencodeEventEvidence, renderedAgentMessages, shouldSuppressCodexDiagnostic, taskAgentId, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, ticketDisplaySlug } from './events.mjs'
+import { agentAddedByName, agentStateRequest, buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, codexEventEvidence, codexPolicyBlock, combineRuntimeWorkEvidence, conversationNeedsCode, mentionDedupeKeys, missingRuntimeWorkEvidence, normalizeRenderedMessageText, opencodeEventEvidence, renderedAgentMessages, shouldSuppressCodexDiagnostic, taskAgentId, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, ticketDisplaySlug } from './events.mjs'
 import { createByoMemoryGraph } from './memory.mjs'
 import { repositoryHasPrPushAuthorization } from './pr-push.mjs'
 import { createMcpHttpClient } from './mcp-http.mjs'
@@ -34,7 +34,7 @@ const REPLY_DISCIPLINE = [
   '  • FIRST-PERSON VOICE. Speak as yourself: use “I”, “I\'m”, and “my”. Never refer to yourself by your agent name or in the third person, and never restate your own name in introductions, acknowledgements, progress, blockers, or results. The app already shows who sent the message. Sound like a warm, accountable teammate, not a status bot.',
   '  • IS IT FOR YOU? Act ONLY on messages addressed to YOU — an @mention of your exact name, a direct question to you, or a reply to something YOU said or did. If a DIFFERENT agent or person was @mentioned or asked to do something, STAY OUT: do not answer for them and do not pick up their task. When it is not yours, posting nothing is the correct move.',
   '  • EVENT NAMES ARE NOT OWNERSHIP. A transport may wake you for activity in a thread you once joined. Trust only the watcher\'s verified recipient decision for the current source message; never infer that every thread update is yours.',
-  '  • NO DUPLICATES OR PICKUP NOISE. Before you post, scan the recent thread/channel for what YOU already said. If you already replied to this exact request, do NOT post again. Do not send a generic pickup acknowledgement; activity shows that work is underway. The first durable task message is a verified result, a link, or a real blocker. One answer per question.',
+  '  • NO DUPLICATES OR PICKUP NOISE. Before you post, scan the recent thread/channel for what YOU already said. If you already replied to this exact request, do NOT repeat the same message. Do not send a generic pickup acknowledgement; activity shows that work is underway. For longer code work, you may send at most one concrete progress update after work has actually begun, but that update NEVER completes the cycle: keep using tools, then send one distinct verified result or real blocker. One final answer per question.',
   '  • BE SURE BEFORE YOU SPEAK. Do not claim something is possible, done, or broken until you have actually verified it — call the tool, read the code, check the real state. Never assert then contradict yourself. If you are unsure, verify FIRST, then give ONE clear, final answer instead of thinking out loud across several messages.',
   '  • USE RECALL, NEVER INVENT IT. Before answering a context-dependent question, search the visible thread and use any available history, search, docs, or recall tools. Reuse verified context instead of asking the user to repeat it. If no record exists, say plainly "I don\'t have a record of that". Never fabricate past events, conversations, results, links, PR numbers, deploy URLs, or figures.',
   '  • TICKET SLUGS, NEVER DATABASE IDS. In every human-facing channel message, ticket comment, PR description, summary, blocker, and result, reference a ticket by the exact project-scoped slug returned by get_ticket/list_tasks (for example, `OVS-57`). Numeric project_id and ticket_id values are internal MCP arguments only: never write `#57`, `ticket 57`, or expose a database id to teammates. If the backend omits the slug, use the ticket title or say “the ticket”; do not invent a slug.',
@@ -79,10 +79,10 @@ const CODE_CHARTER = [
   'CAPABILITY CHECK: before you EVER answer "I can\'t do that", verify against the tools above. If a tool exists for it, DO it. To be explicit: you CAN read/inspect any of the org\'s codebases, clone a repo you don\'t have yet, work on it, create a branch, and raise a PR — say YES to these and then actually do them.',
   '',
   'WORK ETHIC — how a reliable teammate behaves (this is the difference between useful and ignored):',
-  '  1. CLOSE THE LOOP in THIS cycle. Never say "I\'ll do X" and stop. If you commit to something, do it NOW — the human must never have to remind you to circle back.',
+  '  1. CLOSE THE LOOP in THIS cycle. Never say "I\'ll do X" and stop. If you commit to something, do it NOW — the human must never have to remind you to circle back. Sending an intent or progress message is not a stop condition: continue using tools and send the verified result or blocker afterward.',
   '  2. FINISH, then REPORT. Always update/move the ticket with update_ticket. Reply in a supplied human source thread when one exists. For backlog-assigned work, do not call post_message yourself: the watcher publishes one evidence-verified result in the project channel after the PR and ticket handoff are confirmed.',
   '  3. Be honest and specific. Never invent progress. If you are genuinely blocked (missing repo, unclear spec, a failing tool), say exactly what you need in one message — that IS closing the loop.',
-  '  4. One reply per channel per cycle; answer several nudges together.',
+  '  4. One final reply per request; answer several nudges together. A single concrete progress update is allowed during longer work, but it must be followed by the final result or blocker in the same cycle.',
   '  5. RECOVER DEAD COMMAND SESSIONS. If write_stdin reports “Unknown process id”, that command session has already exited. Never poll the same process id again. Start a fresh exec_command when more work is required, then continue the task and verify the final state.',
   '',
   REPLY_DISCIPLINE,
@@ -106,7 +106,7 @@ const CODE_FAST = [
   '  • IF a specific mention/message FOR YOU is given above: reply to THAT ONE message exactly once with post_message, then STOP. Do NOT call poll_inbox and do NOT answer anything else this cycle — polling would re-surface the same message and make you double-post.',
   '  • IF NO specific mention is given above: call poll_inbox and reply only to items directed at YOU (asks you something, or responds to your own message) — SKIP chatter aimed at someone else / another agent; at most one reply per channel.',
   'If the message asks YOU for real CODE work, do the WHOLE job now — branch (checkout -B agent/<slug>), edit, run tests, commit, push your branch, open a PR (gh pr create), then reply once with the PR link and @mention the requester by exact full name. Never push to main, never --force, never merge.',
-  'Post ONE message for the thing you are answering — send it once; never a reply then a "better" version; never repeat a reply you already sent; be sure before you send. Do NOT promise and stop — finish and report in THIS cycle. 1-3 sentences, no summary. Then stop.',
+  'For a non-code question, post ONE answer and stop. For code work, do not post a generic pickup message. You may post one concrete progress update after work starts, but keep working after it; then post one distinct final result with the PR/test evidence or a real blocker. Never repeat the same message. The final update should be 1-3 sentences.',
 ].join('\n')
 
 // ── Workspace-ethics cycles (both chat-only + code agents) ───────────────────
@@ -328,7 +328,7 @@ function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, ma
       // JSON mode is the evidence boundary. Formatted stdout only tells us that
       // OpenCode exited; raw events tell us which tools actually completed.
       const args = ['run', full, '--auto', '--format', 'json', '--dir', workspace, ...(m ? ['--model', m] : [])]
-      let child = null, done = false, didCode = false, didRepoMutation = false, didMessage = false, didChannelMessage = false, didMcpTaskRead = false, didMcpTaskUpdate = false
+      let child = null, done = false, didCode = false, didRepoMutation = false, didMessage = false, didChannelMessage = false, didResultMessage = false, didMcpTaskRead = false, didMcpTaskUpdate = false
       let cancel = null
       let outputText = '', jsonlBuffer = ''
       const mcpCalls = new Set(), mcpErrors = new Set(), runtimeErrors = new Set()
@@ -339,7 +339,7 @@ function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, ma
         clearTimeout(timer)
         const calls = [...mcpCalls]
         log('opencode MCP calls: ' + (calls.length ? calls.join(', ') : 'none') + (mcpErrors.size ? ' (failed: ' + [...mcpErrors].join(', ') + ')' : ''))
-        resolve({ ...o, didCode, didRepoMutation, didMessage, didChannelMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, mcpErrors: [...mcpErrors], outputText })
+        resolve({ ...o, didCode, didRepoMutation, didMessage, didChannelMessage, didResultMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, mcpErrors: [...mcpErrors], outputText })
       }
       const inspectLine = (line) => {
         const value = String(line || '').trim()
@@ -367,6 +367,8 @@ function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, ma
           if (evidence.failed) mcpErrors.add(evidence.mcpTool)
           else if (evidence.completed) mcpErrors.delete(evidence.mcpTool)
         }
+        const repositoryWasChanged = didRepoMutation
+        if (evidence.didChannelMessage && repositoryWasChanged) didResultMessage = true
         didCode ||= !!evidence.didCode
         didRepoMutation ||= !!evidence.didRepoMutation
         didMessage ||= !!evidence.didMessage
@@ -446,7 +448,7 @@ 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, didChannelMessage = false, outputText = '', jsonlBuffer = '', stderrBuffer = '', stderrLineBuffer = ''
+      let child = null, done = false, didCode = false, didRepoMutation = false, didMessage = false, didChannelMessage = false, didResultMessage = false, outputText = '', jsonlBuffer = '', stderrBuffer = '', stderrLineBuffer = ''
       let cancel = null
       let policyBlock = null
       const mcpCalls = new Set(), mcpErrors = new Set()
@@ -458,7 +460,7 @@ 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, didChannelMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, mcpErrors: [...mcpErrors], outputText, policyBlock })
+        resolve({ ...o, didCode, didRepoMutation, didMessage, didChannelMessage, didResultMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, mcpErrors: [...mcpErrors], outputText, policyBlock })
       }
       const inspectDiagnostic = (value) => {
         const s = String(value || '')
@@ -483,24 +485,23 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
         const s = line.trim()
         if (!s) return
         policyBlock = codexPolicyBlock(s) || policyBlock
-        if (/command_execution|file_change|apply_patch|shell_command|exec_command/i.test(s)) didCode = true
-        if (/file_change|apply_patch/i.test(s) || /\b(?:git\s+(?:commit|push)|gh\s+pr\s+create|openvisio-agent\s+push-pr-branch)\b/i.test(s)) didRepoMutation = true
-        if (/post_message|comment_ticket/i.test(s)) didMessage = true
         try {
           const event = JSON.parse(s)
-          const item = event.item ?? event
-          if (item?.type === 'agent_message' && typeof item.text === 'string') outputText += ' ' + item.text
-          if (item?.type === 'mcp_tool_call') {
-            const tool = String(item.tool || item.name || item.method || 'unknown').replace(/^openvisio-team[.:/]/, '')
-            mcpCalls.add(tool)
-            try { onTool && onTool(tool) } catch { /* activity is best-effort */ }
-            if (/^(?:get_ticket|list_tasks|list_task_types)$/.test(tool)) didMcpTaskRead = true
-            if (tool === 'update_ticket') didMcpTaskUpdate = true
-            if (/^(?:create_codebase_branch|create_codebase_commit|write_codebase_file|create_pull_request)$/.test(tool)) { didCode = true; didRepoMutation = true }
-            if (/post_message|comment_ticket/.test(tool)) didMessage = true
-            if (/post_message/.test(tool)) didChannelMessage = true
-            if (/fail|error/i.test(String(item.status || '')) || item.error) mcpErrors.add(tool)
+          const evidence = codexEventEvidence(event)
+          if (evidence.outputText) outputText += ' ' + evidence.outputText
+          if (evidence.mcpTool) {
+            mcpCalls.add(evidence.mcpTool)
+            try { onTool && onTool(evidence.mcpTool) } catch { /* activity is best-effort */ }
+            if (evidence.failed) mcpErrors.add(evidence.mcpTool)
+            else if (evidence.completed) mcpErrors.delete(evidence.mcpTool)
           }
+          if (evidence.didChannelMessage && didRepoMutation) didResultMessage = true
+          didCode ||= !!evidence.didCode
+          didRepoMutation ||= !!evidence.didRepoMutation
+          didMessage ||= !!evidence.didMessage
+          didChannelMessage ||= !!evidence.didChannelMessage
+          didMcpTaskRead ||= !!evidence.didMcpTaskRead
+          didMcpTaskUpdate ||= !!evidence.didMcpTaskUpdate
         } catch { /* non-JSON diagnostic */ }
         if (debug) log('  · ' + s.slice(0, 220))
       }
@@ -567,13 +568,35 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
   let resolveTurn = null
   let cycleTimer = null
   let turnToolCalls = new Set()
+  let turnToolUses = new Map()
+  let turnMcpErrors = new Set()
+  let turnDidCode = false
+  let turnDidRepoMutation = false
+  let turnDidMessage = false
+  let turnDidChannelMessage = false
+  let turnDidResultMessage = false
+  let turnDidMcpTaskRead = false
+  let turnDidMcpTaskUpdate = false
+  let turnOutputText = ''
   const clearCycleTimer = () => { if (cycleTimer) { clearTimeout(cycleTimer); cycleTimer = null } }
   const settleTurn = (o) => {
     clearCycleTimer()
     const r = resolveTurn
     resolveTurn = null
     const mcpCalls = [...turnToolCalls]
-    if (r) r({ ...o, mcpCalls, didChannelMessage: mcpCalls.includes('post_message') })
+    if (r) r({
+      ...o,
+      mcpCalls,
+      mcpErrors: [...turnMcpErrors],
+      didCode: turnDidCode,
+      didRepoMutation: turnDidRepoMutation,
+      didMessage: turnDidMessage,
+      didChannelMessage: turnDidChannelMessage,
+      didResultMessage: turnDidResultMessage,
+      didMcpTaskRead: turnDidMcpTaskRead,
+      didMcpTaskUpdate: turnDidMcpTaskUpdate,
+      outputText: turnOutputText.trim(),
+    })
   }
 
   // --debug: surface what the cycle actually does (tool calls, tool errors, text)
@@ -612,12 +635,25 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
         if (!line.trim()) continue
         let o; try { o = JSON.parse(line) } catch { continue }
         if (debug) logEvent(o)
-        // Surface tool calls (e.g. post_message) so the loop can emit a live status.
-        if (onTool && o.type === 'assistant' && o.message && Array.isArray(o.message.content)) {
-          for (const b of o.message.content) if (b.type === 'tool_use' && b.name) {
-            turnToolCalls.add(String(b.name).replace(/^mcp__openvisio-team__/, ''))
-            try { onTool(b.name) } catch { /* status is best-effort */ }
+        const evidence = claudeEventEvidence(o, turnToolUses)
+        if (evidence.outputText) turnOutputText += (turnOutputText ? ' ' : '') + evidence.outputText
+        for (const name of evidence.toolCalls || []) {
+          turnToolCalls.add(String(name).replace(/^mcp__openvisio-team__/, ''))
+          try { onTool && onTool(name) } catch { /* status is best-effort */ }
+        }
+        for (const fact of evidence.toolResults || []) {
+          if (fact.mcpTool) {
+            turnToolCalls.add(fact.mcpTool)
+            if (fact.failed) turnMcpErrors.add(fact.mcpTool)
+            else if (fact.completed) turnMcpErrors.delete(fact.mcpTool)
           }
+          if (fact.didChannelMessage && turnDidRepoMutation) turnDidResultMessage = true
+          turnDidCode ||= !!fact.didCode
+          turnDidRepoMutation ||= !!fact.didRepoMutation
+          turnDidMessage ||= !!fact.didMessage
+          turnDidChannelMessage ||= !!fact.didChannelMessage
+          turnDidMcpTaskRead ||= !!fact.didMcpTaskRead
+          turnDidMcpTaskUpdate ||= !!fact.didMcpTaskUpdate
         }
         if (o.type === 'result') {
           log('cycle done (' + (o.subtype || 'ok') + (o.is_error ? ' · ERROR' : '') + ')')
@@ -655,6 +691,16 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
       ensureSession()
       turnsThisSession++
       turnToolCalls = new Set()
+      turnToolUses = new Map()
+      turnMcpErrors = new Set()
+      turnDidCode = false
+      turnDidRepoMutation = false
+      turnDidMessage = false
+      turnDidChannelMessage = false
+      turnDidResultMessage = false
+      turnDidMcpTaskRead = false
+      turnDidMcpTaskUpdate = false
+      turnOutputText = ''
       resolveTurn = resolve
       // Backstop: abandon a cycle that never returns a result so `busy` is released
       // and queued mentions can proceed.
@@ -813,7 +859,15 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   let lastTaskTriggeredAt = 0
   let lastInboxSignature = ''
   let selfAgentId = null
+  let completionRecipientName = ''
   const selfAliases = new Set([slug, identifier].map((value) => String(value || '').toLowerCase()).filter(Boolean))
+  const rememberSelfAgent = (self) => {
+    if (!self || typeof self !== 'object') return
+    if (self.id != null) selfAgentId = Number(self.id)
+    for (const alias of [self.name, self.identifier, self.slug]) if (alias) selfAliases.add(String(alias).toLowerCase())
+    const addedBy = agentAddedByName(self)
+    if (addedBy) completionRecipientName = addedBy
+  }
   const mcpClient = createMcpHttpClient({ url: mcpUrl, apiKey, identifier, clientVersion: '0.18.5', log })
   const callMcpTool = (name, args = {}) => mcpClient.callTool(name, args)
   let mcpToolNames = null
@@ -978,7 +1032,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const taskKey = `${projectId}:${ticketId}`
     const current = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
     const ticket = current.ticket ?? current.task ?? current
-    const report = buildTaskCompletionReport(ticket, { projectId, fallbackText: result.outputText })
+    const report = buildTaskCompletionReport(ticket, { projectId, fallbackText: result.outputText, recipientName: completionRecipientName })
     if (!report) return false
     const memoryKey = `ticket:${projectId}:${ticketId}`
     memory.remember({
@@ -1112,8 +1166,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const agents = Array.isArray(agentsData.agents) ? agentsData.agents : []
       const self = agents.find((a) => String(a.identifier || a.slug || '') === identifier)
       if (!self?.id) throw new Error('list_agents did not return this BYO agent')
-      selfAgentId = Number(self.id)
-      for (const alias of [self.name, self.identifier, self.slug]) if (alias) selfAliases.add(String(alias).toLowerCase())
+      rememberSelfAgent(self)
       const projectsData = toolData(await callMcpTool('list_projects'))
       const projects = Array.isArray(projectsData.projects) ? projectsData.projects : []
       const assigned = []
@@ -1232,33 +1285,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   const baseFor = (kind, delivery) => delivery?.watcherOwned
     ? (kind === 'full' ? fullPrompt + '\n\n' + guardedReplyPrompt : guardedReplyPrompt)
     : kind === 'intro' ? INTRO : kind === 'full' ? fullPrompt : (kind === 'coord' || kind === 'sweep') ? coordinatePrompt : fastPrompt
-  // Codex and OpenCode expose structured action streams. Require runtime facts
-  // from those streams before accepting a full coding cycle. Claude's evidence
-  // shape is different and remains on its existing completion path.
-  const evidenceGatedRuntime = agent === 'codex' || agent === 'opencode'
-  const missingWorkEvidence = (result, ticketCycle) => {
-    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)
-    if (result?.mcpErrors?.length) missing.push('resolve failed MCP calls: ' + result.mcpErrors.join(', '))
-    return missing
-  }
-  const combineWorkEvidence = (first, second) => ({
-    ...second,
-    didCode: !!first?.didCode || !!second?.didCode,
-    didRepoMutation: !!first?.didRepoMutation || !!second?.didRepoMutation,
-    didMessage: !!first?.didMessage || !!second?.didMessage,
-    didChannelMessage: !!first?.didChannelMessage || !!second?.didChannelMessage,
-    didMcpTaskRead: !!first?.didMcpTaskRead || !!second?.didMcpTaskRead,
-    didMcpTaskUpdate: !!first?.didMcpTaskUpdate || !!second?.didMcpTaskUpdate,
-    mcpCalls: [...new Set([...(first?.mcpCalls || []), ...(second?.mcpCalls || [])])],
-    // A focused recovery is allowed to clear an earlier MCP failure. Only calls
-    // still failing in the recovery remain blockers.
-    mcpErrors: second?.mcpErrors || [],
-    outputText: [first?.outputText, second?.outputText].filter(Boolean).join(' '),
-  })
+  // Every coding runtime now exposes structured action evidence. A normal CLI
+  // result or assistant prose never closes a work cycle by itself.
+  const cycleSucceeded = (result) => !!result && !result.is_error && [undefined, null, '', 'ok', 'success'].includes(result.subtype)
   const releaseTaskForRetry = (taskRef, prompt) => {
     const directProject = Number(taskRef?.projectId)
     const directTicket = Number(taskRef?.ticketId)
@@ -1323,9 +1352,10 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         catch (e) { log('failed to publish policy blocker: ' + (e?.message || e)) }
         return
       }
-      if (kind === 'full' && ['timeout', 'spawn-failed', 'error'].includes(result?.subtype)) {
-        const notice = `I'm blocked because the coding cycle ended with ${result.subtype}. I'm not claiming completion, and I've left the ticket open for retry.`
-        log('WORK_CYCLE_BLOCKED ' + result.subtype + '; publishing blocker')
+      if (kind === 'full' && !cycleSucceeded(result)) {
+        const outcome = result?.subtype || 'an unknown runtime error'
+        const notice = `I'm blocked because the coding cycle ended with ${outcome}. I'm not claiming completion, and I've left the ticket open for retry.`
+        log('WORK_CYCLE_BLOCKED ' + outcome + '; publishing blocker')
         try { await publishBlocker({ prompt, taskRef: activeTaskRef, notice }) }
         catch (e) { log('failed to publish cycle blocker: ' + (e?.message || e)) }
         releaseTaskForRetry(activeTaskRef, prompt)
@@ -1341,13 +1371,15 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       // Model prose never proves success or a blocker. Full cycles must produce
       // runtime-observed ticket reads, repository evidence, and ticket updates.
       const ticketCycle = !!activeTaskRef || /ticket\s+#?\d+.*?project\s+\d+/i.test(prompt)
-      const missing = missingWorkEvidence(result, ticketCycle)
-      if (evidenceGatedRuntime && kind === 'full' && result?.subtype === 'ok' && missing.length) {
+      const resultMessageRequired = kind === 'full' && !!delivery && !delivery.watcherOwned
+      const missing = missingRuntimeWorkEvidence(result, { ticketCycle, resultMessageRequired })
+      if (kind === 'full' && cycleSucceeded(result) && missing.length) {
         log(agent + ' coding cycle incomplete; recovery requires: ' + missing.join(', '))
-        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, publish an agent/* branch, open the PR, and call update_ticket with the correct board column. ${agent === 'codex' ? 'Prefer the available OpenVisio create_codebase_branch/create_codebase_commit/create_pull_request tools. Only when that linked-codebase flow is unavailable, run openvisio-agent push-pr-branch; never retry a rejected direct git push.' : ''} Post only when the original context supplies a source thread.`, codeModel, delivery?.watcherOwned ? { disabledMcpTools: ['post_message'] } : {})
-        const recoveredResult = combineWorkEvidence(result, recovery)
-        const recoveryMissing = missingWorkEvidence(recoveredResult, ticketCycle)
-        if (recovery?.subtype !== 'ok' || recoveryMissing.length) {
+        const recoveryPrompt = `CONTINUE THE SAME OPENVISIO REQUEST. Your earlier output did not complete it. Missing runtime evidence: ${missing.join('; ')}. An intent or progress message is not completion. Continue the actual work now, verify it, and then post one distinct final result or real blocker in the supplied source thread; a final result after an earlier progress message is explicitly allowed and required. Do not repeat the progress message. ${agent === 'codex' ? 'Prefer the available OpenVisio create_codebase_branch/create_codebase_commit/create_pull_request tools. Only when that linked-codebase flow is unavailable, run openvisio-agent push-pr-branch; never retry a rejected direct git push.' : ''}\n\nORIGINAL REQUEST AND ROUTING CONTEXT:\n${prompt}`
+        const recovery = await runners.work.runCycle(recoveryPrompt, codeModel, delivery?.watcherOwned ? { disabledMcpTools: ['post_message'] } : {})
+        const recoveredResult = combineRuntimeWorkEvidence(result, recovery)
+        const recoveryMissing = missingRuntimeWorkEvidence(recoveredResult, { ticketCycle, resultMessageRequired })
+        if (!cycleSucceeded(recovery) || recoveryMissing.length) {
           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)) }
@@ -1446,8 +1478,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       if (selfAgentId == null) {
         const agentsData = toolData(await callMcpTool('list_agents'))
         const self = (Array.isArray(agentsData.agents) ? agentsData.agents : []).find((a) => String(a.identifier || a.slug || '') === identifier)
-        selfAgentId = self?.id != null ? Number(self.id) : null
-        for (const alias of [self?.name, self?.identifier, self?.slug]) if (alias) selfAliases.add(String(alias).toLowerCase())
+        selfAgentId = null
+        rememberSelfAgent(self)
       }
       const ticketData = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
       const ticket = ticketData.ticket ?? ticketData.task ?? ticketData
@@ -1582,7 +1614,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const ctx = cid != null
         ? replyDelivery?.watcherOwned
           ? `The watcher verified this source message is addressed to you in OpenVisio channel ${cid}${who ? ` by "${who}"` : ''}: "${text}". ${codingMention ? 'Complete the concrete repository work and verification first.' : 'Answer the request directly.'} Do NOT call post_message; it is intentionally unavailable. Return only the final reply as your final answer. The watcher will re-check the live thread and render it at most once.${who ? ` To mention the requester, use their exact full name "@${who}".` : ''} The complete message is already here; do not call get_resource, get_marching_orders, poll_inbox, list_mcp_resources, or list_mcp_resource_templates.`
-          : `The watcher verified this source message is addressed to you in OpenVisio channel ${cid}${who ? ` by "${who}"` : ''}: "${text}". ${codingMention ? 'This is concrete 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. 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.` : ''} The complete message is already here. Do not call get_resource, get_marching_orders, poll_inbox, list_mcp_resources, or list_mcp_resource_templates, and after your single reply, STOP.`
+          : `The watcher verified this source message is addressed to you in OpenVisio channel ${cid}${who ? ` by "${who}"` : ''}: "${text}". ${codingMention ? `This is concrete repository work. Start the coding flow now. You may send at most one concrete progress update after work begins, but do not stop there: continue the work and then send one distinct final result with evidence or a real blocker. Use post_message for the final result even if you already sent a progress message` : '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. Never repeat the same message.${who ? ` To @mention them back, write their EXACT full name "@${who}". A mention only links when the name matches exactly.` : ''} The complete message is already here. Do not call get_resource, get_marching_orders, poll_inbox, list_mcp_resources, or list_mcp_resource_templates.${codingMention ? ' Stop only after the work and final result/blocker.' : ' After your single reply, STOP.'}`
         : undefined
       if (codingMention) {
         // Activity indicators make accepted work visible. Do not add a canned