openvisio-agent 0.18.2 → 0.18.4

package/README.md

@@ -56,12 +56,14 @@ Then `watch --name ada` auto-detects the backend agent and runs a WebSocket loop
 
 Runs the **autonomy loop** — the agent replies to @mentions and picks up tickets on its own. It cheaply polls an inbox endpoint (no model spend when idle) and pokes a single warm Claude Code session only when something new arrives.
 
-Backend/BYO watchers reconcile immediately whenever the process starts or the WebSocket connects. A direct MCP session uses the backend's actual tools (`list_agents`, `list_projects`, `list_tasks`, `list_task_types`, and `list_activity`) to recover assigned tasks and recent mention activity missed while offline. The same zero-model check runs every five minutes as a safety net; a model starts only when pending work exists.
+Backend/BYO watchers reconcile immediately whenever the process starts or the WebSocket connects. A direct MCP session discovers and caches the backend's actual `tools/list` response, then uses available tools such as `list_agents`, `list_projects`, `list_tasks`, `list_task_types`, and `list_activity` to recover assigned tasks and recent mention activity missed while offline. Optional actions such as ticket comments are used only when advertised; their absence cannot strand a completed ticket in a retry loop. The same zero-model check runs every five minutes as a safety net; a model starts only when pending work exists.
 
-The backend MCP may be stateful or stateless. A successful initialize response without `Mcp-Session-Id` is accepted as stateless, so OpenCode agents do not stop with “MCP initialize returned no session id.” Each OpenCode lane keeps its MCP identity in a private per-agent config directory while the repository is supplied separately with `--dir`; stale workspace configuration therefore cannot swap one agent's credentials for another's. The generated remote configuration sends the agent headers directly, disables OAuth probing, and backend cycles never request relay-only `get_marching_orders`, `poll_inbox`, or `get_resource` tools.
+The backend MCP may be stateful or stateless. A successful initialize response without `Mcp-Session-Id` is accepted as stateless, so OpenCode agents do not stop with “MCP initialize returned no session id.” Each OpenCode lane keeps its MCP identity in a private per-agent config directory while the repository is supplied separately with `--dir`; stale workspace configuration therefore cannot swap one agent's credentials for another's. The generated remote configuration sends the agent headers directly, disables OAuth probing, and backend cycles never request relay-only inbox calls or MCP resource-discovery tools in place of team actions.
 
 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.
+
 Claude uses Haiku for routine coordination and Sonnet for repository work. Codex uses `gpt-5.6-sol` for every cycle, including messages, mentions, triage, board movement, MCP calls, and coding. This intentionally favors reliability and consistent tool use over the cheaper Codex tiers.
 
 ```bash

package/package.json

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

@@ -31,6 +31,11 @@ const websocket = readFileSync(join(root, 'src', 'ws.mjs'), 'utf8')
 const activityHook = readFileSync(join(repo, 'frontend', 'hooks', 'useAgentActivity.ts'), 'utf8')
 const taskHook = readFileSync(join(repo, 'frontend', 'hooks', 'useBackendTasks.ts'), 'utf8')
 const liveTasks = readFileSync(join(repo, 'frontend', 'lib', 'collab', 'liveTasks.ts'), 'utf8')
+const agentAutonomy = readFileSync(join(repo, 'frontend', 'lib', 'collab', 'agentAutonomy.ts'), 'utf8')
+const bareRuntime = readFileSync(join(repo, 'frontend', 'lib', 'agents', 'bareRuntime.ts'), 'utf8')
+const bareRun = readFileSync(join(repo, 'frontend', 'app', 'api', 'agent', 'bare', 'run', 'route.ts'), 'utf8')
+const bareDriver = readFileSync(join(repo, 'frontend', 'lib', 'collab', 'bareDriver.ts'), 'utf8')
+const quickReply = readFileSync(join(repo, 'frontend', 'app', 'api', 'agent', 'quick-reply', 'route.ts'), 'utf8')
 const spec = readFileSync(join(repo, 'docs', 'CODEX_BYO_AGENT_SPEC.md'), 'utf8')
 
 const assertions = [
@@ -41,11 +46,16 @@ const assertions = [
   ['assigned coding completion is posted by the watcher', watcher.includes('announceTaskCompletion') && watcher.includes('postMessageOnce({ key: `completion:${report.key}`')],
   ['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)')],
-  ['verified completion is persisted as one ticket comment', watcher.includes("callMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: report.content })") && watcher.includes('reportedTaskComments: [...reportedTaskComments]') && watcher.includes('reportedTaskComments.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')")],
   ['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')],
+  ['conversation wake events are recipient-filtered before model start', watcher.includes('classifyConversationTarget(msg, [...selfAliases])') && events.includes("reason: 'explicit-other-recipient'") && events.includes("reason: 'other-agent-chatter'")],
+  ['coding mentions require an action and concrete repository target', watcher.includes('conversationNeedsCode(text)') && events.includes('const action =') && events.includes('const target =')],
+  ['stand-down and redirects cancel source-thread work across runtimes', watcher.includes('cancelThread(cid, threadRoot') && watcher.includes('activeDelivery') && watcher.includes('cancelCurrent') && watcher.includes("subtype === 'canceled'")],
+  ['thread cancellation is rechecked immediately before watcher delivery', watcher.includes('const newlyCancelled = suppressCancelled()') && watcher.includes('if (newlyCancelled) return newlyCancelled')],
+  ['generic coding pickup messages are absent', !watcher.includes("I've picked this up and will return here with the verified result")],
   ['rendered backend replies are checked before every guarded thread post', watcher.includes("callMcpTool('list_message_thread'") && watcher.includes('renderedAgentMessages(live') && watcher.includes('same-content-rendered')],
   ['Codex cannot race the watcher with post_message', watcher.includes("disabledMcpTools: ['post_message']") && watcher.includes('disabled_tools = [')],
   ['reply delivery keys survive reconnects', watcher.includes('deliveredReplies: [...deliveredReplies]') && watcher.includes('deliveredReplies.has(deliveryKey)')],
@@ -65,16 +75,23 @@ const assertions = [
   ['ticket comments load only on demand', !taskHook.includes('for (const task of tasks)') && taskHook.includes('loadedCommentIds.current.has(taskId)')],
   ['concurrent ticket comment loads share one request', taskHook.includes('commentRequests.current.get(requestKey)') && taskHook.includes('commentRequests.current.set(requestKey, request)')],
   ['backend ticket slugs render uppercase', liveTasks.includes("t.slug?.trim().toUpperCase()")],
+  ['bare-agent inbox ownership is thread scoped', agentAutonomy.includes('lastPostInThread') && !agentAutonomy.includes('lastPostInChannel')],
+  ['ambiguous bare-agent follow-ups fail closed', bareRuntime.includes("return { reply: false, reason: 'reply gate unavailable' }") && bareRuntime.includes('When unsure, stay silent.')],
+  ['bare-agent runs handle one source conversation', bareRun.includes('messageId?: string') && bareRun.includes('const targetRoot = target.parentId ?? target.messageId') && bareDriver.includes('messageId: source.messageId')],
+  ['bare-agent posts have a live conversation guard', bareRun.includes('const canPostMessage') && bareRun.includes('{ canPostMessage }') && bareRuntime.includes('reply suppressed because the live thread was redirected, cancelled, or already answered')],
+  ['quick replies preserve distinct top-level conversations', quickReply.includes('m.parentId ?? m.messageId') && quickReply.includes('...(parentId ? { parentId } : {})')],
   ['completion has an evidence failure gate', watcher.includes('WORK_CYCLE_FAILED')],
   ['OpenCode emits structured events for runtime evidence', watcher.includes("'--format', 'json'") && watcher.includes('opencodeEventEvidence(event)')],
   ['OpenCode API-key MCP disables OAuth probing', opencodeConfig.includes("oauth: false") && opencodeConfig.includes('timeout: 15_000')],
   ['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-only tools', watcher.includes('BACKEND MCP RULE') && watcher.includes('get_marching_orders, poll_inbox, and get_resource are relay-only')],
+  ['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)')],
   ['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')],
+  ['backend MCP tools are discovered and cached', mcpHttp.includes("method: 'tools/list'") && mcpHttp.includes('if (!refresh && toolsCache)') && watcher.includes('discoverMcpTools')],
+  ['missing optional MCP tools use compatibility fallbacks', watcher.includes("reason: 'not-advertised'") && watcher.includes('recording the blocker in the ticket description')],
   ['backend introduction is watcher-owned for every runtime', watcher.includes('void announceIntroduction().then((delivered)')],
   ['Codex policy rejection is captured from stderr', watcher.includes("stdio: ['ignore', 'pipe', 'pipe']") && watcher.includes('forwardDiagnostic(d)') && watcher.includes('inspectDiagnostic(incoming)')],
   ['Codex recoverable subprocess diagnostics are not surfaced as activity', watcher.includes('shouldSuppressCodexDiagnostic(line)') && watcher.includes("forwardDiagnostic('', true)") && watcher.includes('RECOVER DEAD COMMAND SESSIONS')],

package/src/events.mjs

@@ -234,6 +234,59 @@ export function renderedAgentMessages(value, identity = {}) {
   return rows
 }
 
+const cleanAlias = (value) => String(value || '').trim().toLowerCase().replace(/^@/, '')
+
+export function messageSenderIsAgent(message) {
+  const m = message && typeof message === 'object' ? message : {}
+  if (m.senderAgent || m.sender_agent || m.agent || m.agent_id != null || m.sender_agent_id != null || m.senderAgentId != null) return true
+  const sender = [m.sender, m.user, m.author].find((item) => item && typeof item === 'object') || {}
+  const kind = String(sender.type ?? sender.kind ?? sender.sender_type ?? m.sender_type ?? m.author_type ?? '').toLowerCase()
+  return /agent|bot/.test(kind) || sender.agent_id != null || sender.identifier != null || (sender.slug != null && !sender.email)
+}
+
+// WebSocket deployments may fan every reply in a watched thread as
+// `agent:mention`, even when the new message names somebody else. Treat the event
+// name as a wake-up hint only: recipient ownership is decided from the actual
+// message before a model or work lane is allowed to run.
+export function classifyConversationTarget(message, selfAliases) {
+  const m = message && typeof message === 'object' ? message : {}
+  const text = String(m.content ?? m.body ?? m.text ?? m.message ?? '').replace(/\s+/g, ' ').trim()
+  const aliases = new Set((selfAliases || []).map(cleanAlias).filter(Boolean))
+  const mentions = [...text.matchAll(/@([a-z0-9](?:[a-z0-9_.-]*[a-z0-9_-])?)/gi)]
+    .map((match) => ({ name: cleanAlias(match[1]), index: match.index ?? 0, end: (match.index ?? 0) + match[0].length }))
+  const selfMentions = mentions.filter((mention) => aliases.has(mention.name))
+  const otherMentions = mentions.filter((mention) => !aliases.has(mention.name))
+  const explicitSelf = selfMentions.length > 0
+
+  if (messageSenderIsAgent(m) && !explicitSelf) {
+    return { action: 'ignore', reason: 'other-agent-chatter', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
+  }
+  if (!explicitSelf && otherMentions.length) {
+    return { action: 'ignore', reason: 'explicit-other-recipient', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
+  }
+
+  const standDown = /\b(?:do\s+not|don't|dont)\s+(?:pick|take|handle|work\s+on|start|continue)\b|\b(?:stand\s+down|stop\s+(?:working|handling|on\s+this)|leave\s+(?:this|it)\s+(?:alone|to\s+\S+)|cancel\s+(?:this|that|it)|not\s+(?:for|yours?))\b/i.test(text)
+  if (standDown && (explicitSelf || !mentions.length)) {
+    return { action: 'stand_down', reason: 'explicit-stand-down', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
+  }
+
+  if (explicitSelf && requestTargetsLaterAgent(text, selfAliases)) {
+    return { action: 'ignore', reason: 'redirected-to-later-agent', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
+  }
+  return { action: 'handle', reason: explicitSelf ? 'explicit-self-recipient' : 'eligible-follow-up', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
+}
+
+// Require an actionable repository verb and a concrete code/repository object.
+// Broad nouns such as "feature", "API", "file", or "documentation" on their
+// own describe plenty of product conversations and must not start a coding lane.
+export function conversationNeedsCode(value) {
+  const text = String(value || '')
+  if (/\b(?:do\s+not|don't|dont|stop|cancel|stand\s+down)\b/i.test(text)) return false
+  const action = /\b(?:implement|fix|debug|refactor|change|update|add|remove|write|edit|test|build|deploy|release|migrate|wire|integrate)\b/i.test(text)
+  const target = /\b(?:code|codebase|repository|repo|github|branch|commit|pull\s+request|pr|endpoint|route|component|page|screen|ui|function|class|database|migration|schema|package|typescript|javascript|python|swift|rust|golang|css|html|source\s+file|tests?)\b/i.test(text)
+  return action && target
+}
+
 // 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/mcp-http.mjs

@@ -14,6 +14,8 @@ export function createMcpHttpClient({ url, apiKey, identifier, clientVersion, fe
   let sessionId = ''
   let rpcId = 0
   let initializePromise = null
+  let toolsPromise = null
+  let toolsCache = null
 
   const post = (message, withSession = true) => fetchImpl(url, {
     method: 'POST',
@@ -27,7 +29,7 @@ export function createMcpHttpClient({ url, apiKey, identifier, clientVersion, fe
     body: JSON.stringify(message),
   })
 
-  const reset = () => { initialized = false; sessionId = '' }
+  const reset = () => { initialized = false; sessionId = ''; toolsCache = null }
 
   const initialize = () => {
     if (initialized) return Promise.resolve()
@@ -80,6 +82,35 @@ export function createMcpHttpClient({ url, apiKey, identifier, clientVersion, fe
     return result
   }
 
+  const requestTools = async (retried = false) => {
+    await initialize()
+    const hadSession = !!sessionId
+    const res = await post({ jsonrpc: '2.0', id: ++rpcId, method: 'tools/list', params: {} })
+    if (!res.ok) {
+      if (hadSession && !retried && [400, 404, 409, 410].includes(res.status)) {
+        reset()
+        return requestTools(true)
+      }
+      throw new Error(`MCP tools/list HTTP ${res.status}`)
+    }
+    const payload = await parsePayload(res)
+    if (payload.error) throw new Error(`MCP tools/list: ${payload.error.message || 'protocol error'}`)
+    const tools = payload.result?.tools ?? payload.tools
+    if (!Array.isArray(tools)) throw new Error('MCP tools/list returned no tool array')
+    toolsCache = tools
+    return tools
+  }
+
+  // Capability discovery is shared and cached. BYO runtimes use it before
+  // optional actions so a backend deployment that lacks one tool cannot trap a
+  // completed ticket in a permanent retry loop.
+  const listTools = (refresh = false) => {
+    if (!refresh && toolsCache) return Promise.resolve(toolsCache)
+    if (toolsPromise) return toolsPromise
+    toolsPromise = requestTools().finally(() => { toolsPromise = null })
+    return toolsPromise
+  }
+
   const mode = () => !initialized ? 'uninitialized' : sessionId ? 'stateful' : 'stateless'
-  return { callTool, initialize, reset, mode }
+  return { callTool, listTools, initialize, reset, mode }
 }

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, codexPolicyBlock, mentionDedupeKeys, normalizeRenderedMessageText, opencodeEventEvidence, renderedAgentMessages, requestTargetsLaterAgent, shouldSuppressCodexDiagnostic, taskAgentId, taskFromEvent, taskIsAwaitingReview, taskIsCompleted } from './events.mjs'
+import { agentStateRequest, buildTaskCompletionReport, classifyConversationTarget, codexPolicyBlock, conversationNeedsCode, mentionDedupeKeys, normalizeRenderedMessageText, opencodeEventEvidence, renderedAgentMessages, shouldSuppressCodexDiagnostic, taskAgentId, taskFromEvent, taskIsAwaitingReview, taskIsCompleted } from './events.mjs'
 import { createByoMemoryGraph } from './memory.mjs'
 import { repositoryHasPrPushAuthorization } from './pr-push.mjs'
 import { createMcpHttpClient } from './mcp-http.mjs'
@@ -33,7 +33,8 @@ const REPLY_DISCIPLINE = [
   'REPLY DISCIPLINE — read the recent messages FIRST, then decide whether to speak at all:',
   '  • 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.',
-  '  • NO DUPLICATES. Before you post, scan the recent thread/channel for what YOU already said. If you already replied to or acknowledged this exact request, do NOT post again. One acknowledgement per task; one answer per question. While a task is in progress, post again ONLY when you have something genuinely NEW (a result, a link, a real blocker) — never re-post "on it".',
+  '  • 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.',
   '  • 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.',
   '  • CLOSE CONCERNS. Never leave a concern, direct question, correction, or blocker addressed to you without a clear response. Acknowledge the concern, act if you can, then report the verified result. If blocked, name the blocker and the exact next action or owner in one message.',
@@ -42,7 +43,7 @@ const REPLY_DISCIPLINE = [
 
 // ── CHAT-ONLY agents (no --workdir): chat/ticket tools, no code surface. ──────
 const CHAT_CHARTER = [
-  'YOU ARE a connected agent in an OpenVisio team, running in CHAT-ONLY mode. Use only tools that actually appear in your openvisio-team tool list. Backend MCP provides post_message, react_message, list_agents, list_projects, list_tasks, get_ticket, update_ticket, comment_ticket, and list_activity. Some relay runtimes also provide poll_inbox or get_marching_orders. Never call a tool that is absent. You have NO file/Bash/git tools in this mode, so you cannot write code yourself.',
+  'YOU ARE a connected agent in an OpenVisio team, running in CHAT-ONLY mode. Use only tools that actually appear in your openvisio-team tool list. Backend MCP provides post_message, react_message, list_agents, list_projects, list_tasks, get_ticket, update_ticket, and list_activity. A ticket-comment tool is optional and must not be assumed. Some relay runtimes also provide poll_inbox or get_marching_orders. Never call a tool that is absent. You have NO file/Bash/git tools in this mode, so you cannot write code yourself.',
   'WORK ETHIC — behave like a dependable teammate: never leave a promise dangling. Either ACT now (reply, or file a ticket) or say plainly you can\'t and offer to file a ticket / tag a coding agent who can. Never invent progress. Close the loop every cycle — the human should never have to remind you to circle back.',
   '',
   REPLY_DISCIPLINE,
@@ -62,15 +63,15 @@ const CYCLE_FAST = [
 const COORDINATE = [
   'COORDINATION-ONLY cycle. Use the lightweight lane for messaging, triage, ticket comments, assignment, and board movement.',
   'Call get_marching_orders or poll_inbox only when the event context does not already contain enough detail. Use update_ticket to move a ticket to the correct board column when requested or when non-code work is complete.',
-  'Do not inspect repositories, edit files, run tests, or write code in this cycle. If the request actually requires code and this cycle was misclassified, acknowledge it once and state that it needs the coding lane. Do not pretend it is complete.',
-  'Respond to every direct concern assigned to you, but post only once per item and never duplicate an existing acknowledgement.',
+  'Do not inspect repositories, edit files, run tests, or write code in this cycle. If the request actually requires code and this cycle was misclassified, leave it retryable for the coding lane; report only a concrete routing blocker, never a generic acknowledgement. Do not pretend it is complete.',
+  'Respond to every direct concern assigned to you, but post only once per item and never duplicate an existing answer.',
 ].join('\n')
 
 // ── CODE agents (--workdir given): full file + Bash + git/gh surface. ─────────
 // A stable "who you are / how you work" charter prepended to every code cycle.
 const CODE_CHARTER = [
   'YOU ARE a connected CODING agent in an OpenVisio team, running ON THE USER\'S LAPTOP. You have REAL tools — use them; do NOT claim you lack a capability without checking what you actually hold. Your toolbox:',
-  '  • openvisio-team tools — use the names actually present. Backend MCP provides project/task discovery through list_agents, list_projects, list_tasks, get_ticket, update_ticket, and comment_ticket, plus post_message/react_message/list_activity. Relay runtimes may additionally expose poll_inbox or get_marching_orders.',
+  '  • openvisio-team tools — use the names actually present. Backend MCP provides project/task discovery through list_agents, list_projects, list_tasks, get_ticket, and update_ticket, plus post_message/react_message/list_activity. Ticket comments are optional: use a comment tool only when it appears in the current tool list. Relay runtimes may additionally expose poll_inbox or get_marching_orders.',
   '  • Read / Grep / Glob / Edit / Write / MultiEdit — inspect AND change code.',
   '  • Bash — git (branch, commit, push a branch), gh (clone repos, open PRs), run tests/builds.',
   'YOUR WORKSPACE: your working directory is a WORKSPACE ROOT that holds the org\'s repos as subfolders. Reuse existing clones and the context you already verified. Read repository AGENTS.md instructions before changing code. For any task: locate the relevant repo under the workspace; clone it only when it is genuinely absent, then work inside that subfolder. Never ask the user for a path you can discover yourself.',
@@ -95,7 +96,7 @@ const CODE_FULL = [
   '  3. CHANGE + VERIFY: Read/Edit/Write the files; run the tests or build if the repo has them.',
   '  4. COMMIT + PUSH YOUR BRANCH: git add -A && git commit -m "…"; then git push -u origin agent/<slug>. Only ever push your own agent/* branch. Never --force, never push to main/master, never merge.',
   '  5. RAISE A PR: gh pr create --fill --base <default-branch> --head agent/<slug> (a clear title + a body summarizing the change and how you verified it). Never gh pr merge.',
-  '  6. CLOSE THE LOOP: use comment_ticket for a concrete ticket-scoped blocker or clarification, then move/update the ticket with update_ticket. The watcher adds one evidence-verified final ticket comment after handoff. Reply with the summary + PR link in a source thread explicitly supplied by the event. For backlog-only tickets, do not call post_message yourself; the watcher sends one verified project-channel completion message and deduplicates it across reconnects.',
+  '  6. CLOSE THE LOOP: move/update the ticket with update_ticket. Use a ticket-comment tool for a blocker or clarification only when that tool actually appears; otherwise keep the blocker in the ticket update and let the watcher deliver the visible channel result. When a source thread is supplied, follow its explicit delivery rule: either post once or return final text for watcher delivery. For backlog-only tickets, do not call post_message yourself; the watcher sends one verified project-channel completion message and deduplicates it across reconnects.',
   'Bash is for git / gh / tests / clone ONLY — never to hunt for credentials (they are given to you above).',
 ].join('\n')
 
@@ -119,7 +120,7 @@ const INTRO = [
 const SWEEP = [
   'DAILY CATCH-UP — you may have missed items while offline. Prioritize TASKS.',
   'Use the available task/inbox tools. If get_marching_orders/poll_inbox are absent, use list_agents + list_projects + list_tasks to find tasks assigned to your agent identity, then:',
-  '  1. For every task assigned to YOU that you have NOT started or acknowledged: acknowledge once (comment_ticket "Catching up — picking this up now"), then do the work end-to-end and report (branch/PR + a short channel note). Skip tasks assigned to other agents.',
+  '  1. For every task assigned to YOU that you have NOT started: begin the work without a pickup acknowledgement. Use update_ticket while working and report only a verified result or concrete blocker through an actual source channel when one is supplied. Then do the work end-to-end. Skip tasks assigned to other agents.',
   '  2. Answer only the @mentions / follow-ups that were directed at YOU and that you have not already answered — at most one reply per channel. Do not reply to threads aimed at someone else.',
   'If there is genuinely nothing outstanding, STOP silently — do NOT post a "nothing to do" message.',
 ].join('\n')
@@ -301,6 +302,7 @@ function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, ma
   const redactKey = String(mcpHeaders?.['x-agent-api-key'] || '')
   const opencodeConfig = buildOpencodeConfig({ mcpUrl, mcpHeaders })
   let configured = false
+  let cancelActive = null
   const ensureConfig = () => {
     if (configured) return
     configured = true
@@ -326,11 +328,13 @@ function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, ma
       // 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 cancel = null
       let outputText = '', jsonlBuffer = ''
       const mcpCalls = new Set(), mcpErrors = new Set(), runtimeErrors = new Set()
       const finish = (o) => {
         if (done) return
         done = true
+        if (cancelActive === cancel) cancelActive = null
         clearTimeout(timer)
         const calls = [...mcpCalls]
         log('opencode MCP calls: ' + (calls.length ? calls.join(', ') : 'none') + (mcpErrors.size ? ' (failed: ' + [...mcpErrors].join(', ') + ')' : ''))
@@ -374,6 +378,11 @@ function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, ma
         try { child && child.kill() } catch { /* gone */ }
         finish({ type: 'result', subtype: 'timeout' })
       }, maxCycleMs)
+      cancel = () => {
+        try { child && child.kill() } catch { /* gone */ }
+        finish({ type: 'result', subtype: 'canceled' })
+      }
+      cancelActive = cancel
       log('running opencode cycle…' + (m ? ' [' + m + ']' : ''))
       try {
         child = spawn(bin, args, {
@@ -407,7 +416,7 @@ function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, ma
   }
 
   log('opencode runner ready' + (model ? ' [model ' + model + ']' : '') + (canCode ? ' [CODE workspace ' + workspace + '; isolated cfg ' + configDir + ']' : ' [CHAT-ONLY; isolated cfg ' + configDir + ']'))
-  return { runCycle, canCode }
+  return { runCycle, canCode, cancelCurrent: () => cancelActive?.() }
 }
 
 // Codex has a purpose-built non-interactive mode. Run a fresh, ephemeral cycle
@@ -420,6 +429,7 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
   const cwd = workdir || OV_DIR
   const tomlString = (v) => JSON.stringify(String(v))
   const headerEntries = Object.entries(mcpHeaders || {}).map(([k, v]) => `${JSON.stringify(k)} = ${tomlString(v)}`).join(', ')
+  let cancelActive = null
 
   function runCycle(prompt, cycleModel, cycleOptions = {}) {
     return new Promise((resolve) => {
@@ -436,12 +446,14 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
         ...(mcpOverride ? ['-c', mcpOverride] : []),
         full]
       let child = null, done = false, didCode = false, didRepoMutation = false, didMessage = false, didChannelMessage = false, outputText = '', jsonlBuffer = '', stderrBuffer = '', stderrLineBuffer = ''
+      let cancel = null
       let policyBlock = null
       const mcpCalls = new Set(), mcpErrors = new Set()
       let didMcpTaskRead = false, didMcpTaskUpdate = false
       const finish = (o) => {
         if (done) return
         done = true
+        if (cancelActive === cancel) cancelActive = null
         clearTimeout(timer)
         const calls = [...mcpCalls]
         log('codex MCP calls: ' + (calls.length ? calls.join(', ') : 'none') + (mcpErrors.size ? ' (failed: ' + [...mcpErrors].join(', ') + ')' : ''))
@@ -496,6 +508,11 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
         try { child && child.kill() } catch { /* gone */ }
         finish({ type: 'result', subtype: 'timeout' })
       }, maxCycleMs)
+      cancel = () => {
+        try { child && child.kill() } catch { /* gone */ }
+        finish({ type: 'result', subtype: 'canceled' })
+      }
+      cancelActive = cancel
       log('running codex cycle…' + (m ? ' [' + m + ']' : ''))
       try {
         // Always inspect Codex JSONL so a successful process exit cannot be
@@ -526,7 +543,7 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
 
   if (!mcpUrl) log('WARNING: no --mcp-url — Codex has no openvisio-team tools to act with. Re-connect with --mcp-url.')
   log('codex runner ready' + (model ? ' [model ' + model + ']' : '') + (canCode ? ' [CODE workspace ' + cwd + ']' : ' [CHAT-ONLY]'))
-  return { runCycle, canCode }
+  return { runCycle, canCode, cancelCurrent: () => cancelActive?.() }
 }
 
 // ── Claude Code warm-session cycle runner (shared by the REST + WS loops) ─────
@@ -652,7 +669,14 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
     })
   }
 
-  return { runCycle, canCode }
+  const cancelCurrent = () => {
+    const active = child
+    if (!active) return
+    child = null
+    try { active.kill() } catch { /* gone */ }
+    settleTurn({ type: 'result', subtype: 'canceled' })
+  }
+  return { runCycle, canCode, cancelCurrent }
 }
 
 // ── the backend WS loop ──────────────────────────────────────────────────────
@@ -687,7 +711,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   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.
-  const credNote = `AUTH: the openvisio-team tools REQUIRE two arguments on EVERY call — agent_identifier: "${identifier}" and agent_api_key: "${apiKey}". Include BOTH on every openvisio-team tool call. Use ONLY names shown in the current tool list. On backend MCP, discover and update work with list_agents, list_projects, list_tasks, list_task_types, get_ticket, update_ticket, comment_ticket, list_channels, list_message_thread, and list_activity as applicable. get_marching_orders, poll_inbox, and get_resource are relay-only and are NOT available here; never call them. Tools may be namespaced — call whichever names actually appear. The credentials are given here; do NOT hunt for them. Bash/git/gh ARE for code work; this rule only forbids searching for keys.`
+  const credNote = `AUTH: the openvisio-team tools REQUIRE two arguments on EVERY call — agent_identifier: "${identifier}" and agent_api_key: "${apiKey}". Include BOTH on every openvisio-team tool call. Use ONLY names shown in the current tool list. On backend MCP, discover and update work with list_agents, list_projects, list_tasks, list_task_types, get_ticket, update_ticket, list_channels, list_message_thread, and list_activity as applicable. Ticket comments are optional: never invent or call comment_ticket unless that exact tool appears. get_marching_orders, poll_inbox, get_resource, list_mcp_resources, and list_mcp_resource_templates are NOT team-action tools here; never call them. Tools may be namespaced — call whichever names actually appear. The credentials are given here; do NOT hunt for them. Bash/git/gh ARE for code work; this rule only forbids searching for keys.`
   // The STATIC charter + creds are the session system prompt (cached, billed once),
   // NOT re-sent in every cycle's user message — the big token saving.
   const systemPrompt = (canCode ? CODE_CHARTER : CHAT_CHARTER) + '\n\n' + credNote
@@ -704,10 +728,11 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   const codexPushGuide = agent === 'codex' && canCode
     ? '\n\nCODEX PR DELIVERY: first inspect the OpenVisio MCP tools. When list_codebases, create_codebase_branch, create_codebase_commit (or write_codebase_file), and create_pull_request are available, use that authenticated linked-codebase flow to create the agent/* branch, publish the verified changed files, and open the PR. This is the preferred path and requires no local git push. If those tools are unavailable for the repository, do not run git push directly. From the repository run `openvisio-agent push-pr-branch`. It is a user-authorized constrained fallback that can only push HEAD to the matching agent/* branch on the exact authorized origin. If it reports OPENVISIO_PR_PUSH_AUTH_REQUIRED, do not retry or route around it. Report the one-time command `openvisio-agent authorize-pr-push` as the blocker.'
     : ''
-  const backendToolRule = 'BACKEND MCP RULE: the event and watcher already provide the work source. Never call get_marching_orders, poll_inbox, get_resource, or other relay-only tools; they are not exposed by the backend MCP. Use only names present in the current openvisio-team tool list. For discovery use list_agents, list_projects, list_tasks, list_task_types, list_activity, get_ticket, and list_channels as applicable.'
+  const backendToolRule = 'BACKEND MCP RULE: the event and watcher already provide the work source. Never call get_marching_orders, poll_inbox, get_resource, list_mcp_resources, list_mcp_resource_templates, or other relay/resource-discovery tools; they are not backend team actions. Use only names present in the current openvisio-team tool list. For discovery use list_agents, list_projects, list_tasks, list_task_types, list_activity, get_ticket, and list_channels as applicable. Never call comment_ticket unless that exact optional tool is present.'
   const fullPrompt = (canCode ? CODE_FULL + codexPushGuide : 'Handle the supplied verified backend ticket with the available OpenVisio tools. Update or comment on the ticket as requested, do not claim repository work in chat-only mode, and stop after the verified action.') + '\n\n' + backendToolRule
   const fastPrompt = (canCode ? CODE_FAST : CYCLE_FAST) + '\n\n' + backendToolRule
   const coordinatePrompt = COORDINATE + '\n\n' + backendToolRule
+  const guardedReplyPrompt = 'WATCHER-DELIVERED REPLY: the watcher has already verified that the current source message is addressed to you. Do not call post_message or any inbox/resource-discovery tool. Return only one natural, context-specific reply of 1-3 sentences. Do not echo the request, announce a plan, or add a generic acknowledgement. If the supplied context says the work was completed, lead with the verified result; if it is blocked, name only the real blocker and next action.' + '\n\n' + backendToolRule
   // Live model state — changeable at runtime by the in-chat `/model` command.
   // codeModel drives full/sweep cycles; chatModel (if set) the lighter fast/intro
   // ones, so routine chatter can run cheaper than real code work.
@@ -715,8 +740,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(), taskRefs: [], deferred: [] },
-    reply: { busy: false, queued: null, pending: [], targets: new Set(), taskRefs: [], deferred: [] },
+    work: { busy: false, queued: null, pending: [], targets: new Set(), taskRefs: [], deferred: [], activeDelivery: null },
+    reply: { busy: false, queued: null, pending: [], targets: new Set(), taskRefs: [], deferred: [], activeDelivery: null },
   }
   // 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
@@ -787,8 +812,47 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   let lastTaskTriggeredAt = 0
   let lastInboxSignature = ''
   let selfAgentId = null
-  const mcpClient = createMcpHttpClient({ url: mcpUrl, apiKey, identifier, clientVersion: '0.18.2', log })
+  const selfAliases = new Set([slug, identifier].map((value) => String(value || '').toLowerCase()).filter(Boolean))
+  const mcpClient = createMcpHttpClient({ url: mcpUrl, apiKey, identifier, clientVersion: '0.18.4', log })
   const callMcpTool = (name, args = {}) => mcpClient.callTool(name, args)
+  let mcpToolNames = null
+  let mcpToolDiscoveryPromise = null
+  let mcpToolDiscoveryWarned = false
+  const discoverMcpTools = (refresh = false) => {
+    if (!refresh && mcpToolNames) return Promise.resolve(mcpToolNames)
+    if (mcpToolDiscoveryPromise) return mcpToolDiscoveryPromise
+    mcpToolDiscoveryPromise = mcpClient.listTools(refresh).then((tools) => {
+      mcpToolNames = new Set(tools.map((tool) => String(tool?.name || '')).filter(Boolean))
+      const required = ['list_agents', 'list_projects', 'list_tasks', 'get_ticket', 'update_ticket', 'post_message']
+      const missing = required.filter((name) => !mcpToolNames.has(name))
+      log(`MCP tools ready (${mcpToolNames.size})${missing.length ? '; missing core tools: ' + missing.join(', ') : ''}`)
+      return mcpToolNames
+    }).finally(() => { mcpToolDiscoveryPromise = null })
+    return mcpToolDiscoveryPromise
+  }
+  const mcpSupports = async (name) => {
+    try { return (await discoverMcpTools()).has(name) }
+    catch (e) {
+      if (!mcpToolDiscoveryWarned) {
+        mcpToolDiscoveryWarned = true
+        log('MCP tool discovery failed; optional actions will use compatibility fallbacks: ' + (e?.message || e))
+      }
+      return null
+    }
+  }
+  const callOptionalMcpTool = async (name, args) => {
+    const supported = await mcpSupports(name)
+    if (supported === false) return { called: false, reason: 'not-advertised' }
+    try { return { called: true, result: await callMcpTool(name, args) } }
+    catch (e) {
+      if (/\b(?:unknown|missing|unsupported) tool\b|\btool\b.*\bnot found\b/i.test(String(e?.message || e))) {
+        try { await discoverMcpTools(true) } catch { /* the original error is enough */ }
+        return { called: false, reason: 'not-available' }
+      }
+      throw e
+    }
+  }
+  if (mcpUrl) void discoverMcpTools().catch(() => {})
   const toolData = (result) => {
     const text = result?.content?.find?.((c) => c?.type === 'text')?.text
     if (typeof text !== 'string') return result?.structuredContent ?? result ?? {}
@@ -800,12 +864,39 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   // rendered as this agent. A persisted delivery key closes the crash/reconnect
   // gap; an in-flight promise closes the two-lane race inside one watcher.
   const messageDeliveries = new Map()
-  const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '' }) => {
+  const threadControlKey = (channelId, parentId) => Number.isFinite(Number(channelId)) && parentId != null ? `thread:${Number(channelId)}:${parentId}` : ''
+  const sameDeliveryThread = (delivery, channelId, parentId) => delivery && Number(delivery.channelId) === Number(channelId) && String(delivery.parentId ?? '') === String(parentId ?? '')
+  const cancelThread = (channelId, parentId, summary) => {
+    const controlKey = threadControlKey(channelId, parentId)
+    if (!controlKey) return
+    memory.remember({ key: controlKey, kind: 'thread', state: 'cancelled', summary, refs: { channelId: Number(channelId), threadId: parentId } })
+    for (const [laneName, lane] of Object.entries(lanes)) {
+      lane.deferred = lane.deferred.filter((item) => !sameDeliveryThread(item.delivery, channelId, parentId))
+      if (sameDeliveryThread(lane.activeDelivery, channelId, parentId)) {
+        log(`${laneName} lane cancelled by a newer redirect/stand-down in thread ${parentId}`)
+        runners[laneName].cancelCurrent?.('thread-cancelled')
+      }
+    }
+  }
+  const activateThread = (channelId, parentId, summary) => {
+    const controlKey = threadControlKey(channelId, parentId)
+    if (controlKey) memory.remember({ key: controlKey, kind: 'thread', state: 'active', summary, refs: { channelId: Number(channelId), threadId: parentId } })
+  }
+  const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', allowCancelled = false }) => {
     const deliveryKey = String(key || '')
     const message = String(content || '').trim()
     if (!deliveryKey || !Number.isFinite(Number(channelId)) || !message) return { posted: false, reason: 'invalid-delivery' }
     if (deliveredReplies.has(deliveryKey) || memory.has(deliveryKey, 'rendered')) return { posted: false, reason: 'remembered' }
     if (messageDeliveries.has(deliveryKey)) return messageDeliveries.get(deliveryKey)
+    const controlKey = threadControlKey(channelId, parentId)
+    const suppressCancelled = () => {
+      if (allowCancelled || !controlKey || !memory.has(controlKey, 'cancelled')) return null
+      deliveredReplies.add(deliveryKey); trimSeen(deliveredReplies); persistReplay()
+      memory.remember({ key: deliveryKey, kind: 'delivery', state: 'suppressed', summary: 'A newer redirect or stand-down cancelled this reply.', refs: { channelId: Number(channelId), threadId: parentId } })
+      return { posted: false, reason: 'thread-cancelled' }
+    }
+    const initiallyCancelled = suppressCancelled()
+    if (initiallyCancelled) return initiallyCancelled
 
     const run = (async () => {
       if (parentId != null) {
@@ -821,6 +912,11 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         }
       }
 
+      // A redirect can arrive while the authoritative thread read is in flight.
+      // Re-check immediately before the irreversible post.
+      const newlyCancelled = suppressCancelled()
+      if (newlyCancelled) return newlyCancelled
+
       sendStatus(Number(channelId), 'typing')
       const result = toolData(await callMcpTool('post_message', {
         ...(Number.isFinite(Number(projectId)) ? { project_id: Number(projectId) } : {}),
@@ -892,13 +988,18 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       refs: { projectId, ticketId },
       meta: { reportKey: report.key, prUrl: report.prUrl },
     })
-    // Ticket comments are now a backend first-class surface. The watcher owns the
-    // final comment so every runtime (Claude, Codex, OpenCode) closes the ticket
-    // loop consistently, and the persisted report key prevents reconnect repeats.
+    // Ticket comments are optional across backend deployments. Prefer the tool
+    // when advertised, but never let its absence block the verified channel
+    // handoff or trap the ticket in reconnect retries.
     if (!reportedTaskComments.has(report.key)) {
-      await callMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: report.content })
+      try {
+        const comment = await callOptionalMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: report.content })
+        if (comment.called) log('posted verified ticket comment for #' + ticketId)
+        else log('comment_ticket is not exposed; completing ticket #' + ticketId + ' through its verified state and project-channel report')
+      } catch (e) {
+        log('optional ticket comment failed for #' + ticketId + ': ' + (e?.message || e) + '; continuing with the verified project-channel report')
+      }
       reportedTaskComments.add(report.key); trimSeen(reportedTaskComments); persistReplay()
-      log('posted verified ticket comment for #' + ticketId)
     }
     if (reportedCompletions.has(report.key)) {
       pendingCompletionReports.delete(taskKey)
@@ -959,12 +1060,10 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       refs: { projectId, ticketId, ...(Number.isFinite(channelId) ? { channelId } : {}) },
     })
     try {
-      await callMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: ticketNotice })
-      delivered = true
-      return
-    } catch (e) {
-      log('comment_ticket failed for blocker; falling back to the ticket description for #' + ticketId)
-    }
+      const comment = await callOptionalMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: ticketNotice })
+      if (comment.called) { delivered = true; return }
+      log('comment_ticket is not exposed; recording the blocker in the ticket description for #' + ticketId)
+    } catch (e) { log('optional ticket comment failed; recording the blocker in the ticket description for #' + 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 || '')
@@ -1013,6 +1112,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       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())
       const projectsData = toolData(await callMcpTool('list_projects'))
       const projects = Array.isArray(projectsData.projects) ? projectsData.projects : []
       const assigned = []
@@ -1062,13 +1162,16 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         const mentionNeedles = [self.name, self.identifier, self.slug, identifier].filter(Boolean).map((s) => '@' + String(s).toLowerCase())
         for (const item of activities) {
           const text = JSON.stringify(item)
-          const lower = text.toLowerCase()
           const activityKey = String(project.id) + ':' + String(item.id ?? item.message_id ?? item.messageId ?? text.slice(0, 500))
-          if (!seenActivities.has(activityKey) && mentionNeedles.some((needle) => lower.includes(needle)) && /message|mention|channel/i.test(text)) {
-            const data = item?.data && typeof item.data === 'object' ? item.data : null
-            const activityMessage = item?.message && typeof item.message === 'object'
-              ? item.message
-              : data?.message && typeof data.message === 'object' ? data.message : item
+          const data = item?.data && typeof item.data === 'object' ? item.data : null
+          const activityMessage = item?.message && typeof item.message === 'object'
+            ? item.message
+            : data?.message && typeof data.message === 'object' ? data.message : item
+          const activityText = String(activityMessage?.content ?? activityMessage?.body ?? activityMessage?.text ?? '').toLowerCase()
+          // Reconciliation recovers explicit mentions only. Searching the whole
+          // activity envelope can match an old thread root and replay a new reply
+          // that is actually addressed to another agent.
+          if (!seenActivities.has(activityKey) && mentionNeedles.some((needle) => activityText.includes(needle)) && /message|mention|channel/i.test(text)) {
             const activityChannelId = item?.channel_id ?? item?.channelId ?? data?.channel_id ?? data?.channelId
             seenActivities.add(activityKey); trimSeen(seenActivities); activityReplayTouched = true
             // The same logical mention may already have arrived over WebSocket.
@@ -1124,7 +1227,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
 
   // Higher rank wins when coalescing cycles requested while one is running.
   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') ? coordinatePrompt : fastPrompt
+  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.
@@ -1180,6 +1285,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     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
+    lane.activeDelivery = delivery
     const ctx = lane.pending.splice(0)
     const activeTaskRef = lane.taskRefs.splice(0)[0] || null
     const targets = [...lane.targets]
@@ -1191,7 +1297,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       ? { channelId: delivery.channelId, threadId: delivery.parentId }
       : activeTaskRef ? { projectId: activeTaskRef.projectId, ticketId: activeTaskRef.ticketId } : {}
     const recalled = memory.context(memoryRefs)
-    const prompt = (ctx.length ? ctx.join('\n') + '\n\n' : '') + (recalled ? recalled + '\n\n' : '') + baseFor(kind)
+    const prompt = (ctx.length ? ctx.join('\n') + '\n\n' : '') + (recalled ? recalled + '\n\n' : '') + baseFor(kind, delivery)
     // Chat-shaped cycles (mentions/intro) may run on the cheaper chat model; code
     // work (full/sweep) uses the main model.
     const useModel = agent === 'codex' ? codeModel : kind === 'full' ? codeModel : liteModel
@@ -1203,8 +1309,12 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     // 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, agent === 'codex' && delivery ? { disabledMcpTools: ['post_message'] } : {})
+      const result = await runners[laneName].runCycle(prompt, useModel, delivery?.watcherOwned ? { disabledMcpTools: ['post_message'] } : {})
       let completionResult = result
+      if (result?.subtype === 'canceled') {
+        log(laneName + ' cycle cancelled; no blocker or reply will be published')
+        return
+      }
       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) }
@@ -1232,7 +1342,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const missing = missingWorkEvidence(result, ticketCycle)
       if (evidenceGatedRuntime && kind === 'full' && result?.subtype === 'ok' && 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, agent === 'codex' && delivery ? { disabledMcpTools: ['post_message'] } : {})
+        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) {
@@ -1263,7 +1373,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
           log('completion report failed for ticket #' + activeTaskRef.ticketId + ': ' + (e?.message || e) + '; retained for reconnect retry')
         }
       }
-      if (agent === 'codex' && delivery) {
+      if (delivery?.watcherOwned) {
         const reply = String(completionResult?.outputText || '').trim()
         if (!reply) {
           log('guarded reply produced no final text; leaving delivery unrecorded for retry')
@@ -1276,6 +1386,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       if (heartbeat) clearInterval(heartbeat)
       laneStatusTargets[laneName].clear()
       lane.busy = false
+      lane.activeDelivery = null
       const deferred = lane.deferred.shift()
       if (deferred) void drain(deferred.kind, deferred.context, deferred.targetChannels, deferred.taskRef, deferred.delivery)
       else if (lane.queued || lane.pending.length) { const next = lane.queued || (laneName === 'work' ? 'full' : 'fast'); lane.queued = null; void drain(next) }
@@ -1290,10 +1401,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     return (`${s.first_name || ''} ${s.last_name || ''}`.trim() || s.name || s.email || '')
   }
 
-  // Route obvious repository work to the coding lane. Everything else, including
-  // chat and board movement, stays on the lightweight coordination model.
-  const needsCode = (value) => /\b(?:code|coding|implement|implementation|create|make|design|fix|bug|debug|refactor|test|tests|build|compile|repository|repo|github|git|branch|commit|pull request|pr|endpoint|api|component|feature|page|screen|ui|function|class|database|migration|schema|deploy|release|package|npm|typescript|javascript|python|swift|rust|golang|css|html|file|files|documentation)\b/i.test(String(value || ''))
-  const coordinationOnly = (value) => /\b(?:move|moving|status|column|assign|reassign|unassign|comment|reply|message|triage|prioriti[sz]e|label|rename|close|reopen)\b/i.test(String(value || '')) && !needsCode(value)
+  // Route only concrete repository requests to the coding lane. Conversation
+  // ownership is classified separately before this is consulted.
+  const coordinationOnly = (value) => /\b(?:move|moving|status|column|assign|reassign|unassign|comment|reply|message|triage|prioriti[sz]e|label|rename|close|reopen)\b/i.test(String(value || '')) && !conversationNeedsCode(value)
 
   // Engineers change the model under the hood from chat: "/model", "/model sonnet",
   // "use model haiku", "switch model to opus". Returns {report} | {set} | {invalid}.
@@ -1335,6 +1445,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         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())
       }
       const ticketData = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
       const ticket = ticketData.ticket ?? ticketData.task ?? ticketData
@@ -1403,15 +1514,35 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       // NOT trigger a second reply. Key by message id, or a channel+text signature
       // when the payload carries no id.
       if (!raw._mentionAlreadyMarked && markMentionHandled(msg, cid)) { log('agent:mention (dup) — skipped'); return }
-      if (requestTargetsLaterAgent(text, [slug, identifier])) {
-        log('agent:mention addressed to a later-mentioned agent — skipped')
+      const target = classifyConversationTarget(msg, [...selfAliases])
+      if (target.action === 'ignore') {
+        log('agent:mention ignored before model start (' + target.reason + ')')
+        // A redirect or another agent taking over invalidates any older work or
+        // draft still queued for this thread. The event name alone cannot retain
+        // ownership after the actual message says otherwise.
+        if (cid != null && threadRoot != null && (target.reason === 'explicit-other-recipient' || target.reason === 'other-agent-chatter' || target.reason === 'redirected-to-later-agent')) {
+          cancelThread(cid, threadRoot, text || target.reason)
+        }
         return
       }
       const mentionKeys = mentionDedupeKeys(msg, cid)
       const sourceKey = `mention:${cid ?? '?'}:${mentionKeys.idKey || mentionKeys.signatureKey || threadRoot || Date.now()}`
+      if (target.action === 'stand_down') {
+        if (cid != null && threadRoot != null) {
+          cancelThread(cid, threadRoot, text || 'Explicit stand-down')
+          const confirmation = `${who ? `@${who} ` : ''}Understood. I'm standing down.`
+          void postMessageOnce({ key: `stand-down:${cid}:${threadRoot}`, channelId: Number(cid), parentId: threadRoot, content: confirmation, sourceKey, allowCancelled: true })
+            .catch((e) => log('stand-down confirmation failed closed: ' + (e?.message || e)))
+        }
+        return
+      }
+      if (cid != null && threadRoot != null) activateThread(cid, threadRoot, text)
       memory.remember({ key: sourceKey, kind: 'mention', state: 'received', summary: text, refs: { channelId: cid, threadId: threadRoot, messageId: mid } })
-      const guardedDelivery = (stage = 'reply', skipIfAnyAgentReply = stage !== 'result') => agent === 'codex' && cid != null
-        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey }
+      // Every runtime carries the source thread through the queue so a later
+      // redirect can cancel its process. Codex additionally delegates the final
+      // post to the watcher for an authoritative last-moment thread check.
+      const conversationDelivery = (stage = 'reply', skipIfAnyAgentReply = stage !== 'result') => cid != null
+        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, watcherOwned: agent === 'codex' }
         : null
       // Under-the-hood model control from chat (view / switch the model the agent runs).
       const mcmd = cid != null ? parseModelCmd(text) : null
@@ -1419,11 +1550,11 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         const thread = threadRoot != null ? `, parent_id ${threadRoot}` : ''
         if (mcmd.report) {
           log('model query → code ' + codeModel + ' / chat ' + liteModel)
-          const delivery = guardedDelivery('model')
-          void drain('fast', `An engineer asked which model you're running. ${delivery ? `Return exactly this one-line final answer without calling post_message: "I'm on ${codeModel} for code work${liteModel !== codeModel ? ` and ${liteModel} for chat replies` : ' (and chat)'}.” The watcher will verify and deliver it once.` : `Reply once in channel ${cid}${thread} (with your agent creds): "I'm on ${codeModel} for code work${liteModel !== codeModel ? ` and ${liteModel} for chat replies` : ' (and chat)'}.” One line. Then stop.`}`, [cid], null, delivery)
+          const delivery = conversationDelivery('model')
+          void drain('fast', `An engineer asked which model you're running. ${delivery?.watcherOwned ? `Return exactly this one-line final answer without calling post_message: "I'm on ${codeModel} for code work${liteModel !== codeModel ? ` and ${liteModel} for chat replies` : ' (and chat)'}.” The watcher will verify and deliver it once.` : `Reply once in channel ${cid}${thread} (with your agent creds): "I'm on ${codeModel} for code work${liteModel !== codeModel ? ` and ${liteModel} for chat replies` : ' (and chat)'}.” One line. Then stop.`}`, [cid], null, delivery)
         } else if (mcmd.invalid) {
-          const delivery = guardedDelivery('model')
-          void drain('fast', `An engineer tried to switch your model to "${mcmd.invalid}", which isn't one you recognize. ${delivery ? 'Return one short final answer saying you support "opus", "sonnet", "haiku", or a full model id and asking which they meant. Do not call post_message; the watcher will verify and deliver it once.' : `Reply once in channel ${cid}${thread} (with your agent creds): say you support "opus", "sonnet", "haiku", or a full "claude-…" id, and ask which they meant. One line. Then stop.`}`, [cid], null, delivery)
+          const delivery = conversationDelivery('model')
+          void drain('fast', `An engineer tried to switch your model to "${mcmd.invalid}", which isn't one you recognize. ${delivery?.watcherOwned ? 'Return one short final answer saying you support "opus", "sonnet", "haiku", or a full model id and asking which they meant. Do not call post_message; the watcher will verify and deliver it once.' : `Reply once in channel ${cid}${thread} (with your agent creds): say you support "opus", "sonnet", "haiku", or a full "claude-…" id, and ask which they meant. One line. Then stop.`}`, [cid], null, delivery)
         } else {
           const tgt = mcmd.target // 'chat' | 'code' | 'both'
           const prev = `code ${codeModel}/chat ${liteModel}`
@@ -1433,8 +1564,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
           persistModel()
           const label = tgt === 'chat' ? 'chat model' : tgt === 'code' ? 'code model' : 'model'
           log('model switched (' + tgt + ') ' + prev + ' → code ' + codeModel + '/chat ' + liteModel + (who ? ' (by ' + who + ')' : ''))
-          const delivery = guardedDelivery('model')
-          void drain('fast', `An engineer switched your ${label} to "${mcmd.set}" — active for your next ${tgt === 'chat' ? 'chat replies' : tgt === 'code' ? 'code cycles' : 'actions'}. ${delivery ? `Return one short final confirmation such as "Switched my ${label} to ${mcmd.set}. I'll use it from here." Do not call post_message; the watcher will verify and deliver it once.` : `Post ONE short confirmation in channel ${cid}${thread} (with your agent creds): e.g. "Switched my ${label} to ${mcmd.set} — I'll use it from here." Then stop.`}`, [cid], null, delivery)
+          const delivery = conversationDelivery('model')
+          void drain('fast', `An engineer switched your ${label} to "${mcmd.set}" — active for your next ${tgt === 'chat' ? 'chat replies' : tgt === 'code' ? 'code cycles' : 'actions'}. ${delivery?.watcherOwned ? `Return one short final confirmation such as "Switched my ${label} to ${mcmd.set}. I'll use it from here." Do not call post_message; the watcher will verify and deliver it once.` : `Post ONE short confirmation in channel ${cid}${thread} (with your agent creds): e.g. "Switched my ${label} to ${mcmd.set} — I'll use it from here." Then stop.`}`, [cid], null, delivery)
         }
         return
       }
@@ -1442,23 +1573,17 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       // 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 replyDelivery = guardedDelivery(codingMention ? 'result' : 'reply', !codingMention)
+      const codingMention = canCode && conversationNeedsCode(text)
+      const replyDelivery = conversationDelivery(codingMention ? 'result' : 'reply', !codingMention)
       const ctx = cid != null
-        ? replyDelivery
-          ? `You were @mentioned in OpenVisio channel ${cid}${who ? ` by "${who}"` : ''}: "${text}". This mention is FOR YOU. ${codingMention ? 'Complete the repository work and verification first.' : 'Answer the request.'} Do NOT call post_message; it is intentionally unavailable. Return only the final 1-3 sentence reply as your final answer. The watcher will read the real thread, check its persistent memory graph, and render that answer 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, or poll_inbox.`
-          : `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.` : ''} The complete message is already here. Do not call get_resource, get_marching_orders, or poll_inbox, and after your single reply, STOP.`
+        ? 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.`
         : undefined
       if (codingMention) {
-        if (agent === 'codex' && cid != null) {
-          const ack = `${who ? `@${who} ` : ''}I've picked this up and will return here with the verified result.`
-          void postMessageOnce({ ...guardedDelivery('ack'), content: ack }).catch((e) => log('guarded acknowledgement failed closed: ' + (e?.message || e)))
-        } else {
-          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, cid == null ? [] : [cid])
-        }
+        // Activity indicators make accepted work visible. Do not add a canned
+        // pickup message; the first channel message is the verified result or a
+        // concrete blocker from the work lane.
         void drain('full', ctx, cid == null ? [] : [cid], null, replyDelivery)
       } else void drain('fast', ctx, cid == null ? [] : [cid], null, replyDelivery)
     } else if (k === 'error') {