openvisio-agent 0.25.7 → 0.25.8

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+## [0.25.8] — 2026-09-21
+
+- Hydrate compact `list_agents` identities through `get_agent` so watchers subscribe to their verified organization and receive mentions from every accessible channel.
+- Route organization `task:created` and `task:updated` events through the same authoritative assignment verification used by targeted assignment events.
+- Allow explicit requests to publish in another named channel while retaining guarded, single-delivery replies in the source thread and dedicated-channel defaults for unsolicited results.
+- Start organization discovery immediately after each WebSocket connection and retain event-driven idle behavior.
+
 ## [0.25.7] — 2026-09-21
 
 - Restore recovery for addressed messages that the backend omits from the watcher WebSocket stream.

package/README.md

@@ -87,7 +87,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 reply/work queues, authoritative `get_ticket` verification for assignments, silent transient activity, persistent replay suppression, and agent-controlled turn completion. Maintainers must run `npm run certify` before publishing.
 
-Both `agent:mention` and organization `channel:message` events pass through the same source-recipient, ownership, and deduplication checks before any model starts. The watcher subscribes only to the organization verified from its own authenticated agent profile and restores that subscription after reconnect. Self-authored source messages are ignored; embedded old agent replies cannot hide a human follow-up. An explicit tag establishes durable ownership of that thread, so later human follow-ups remain addressed to the agent without another @mention. Messages redirected to another agent and unaddressed agent chatter stay silent, while a direct stand-down cancels queued/running work and releases ownership for that thread. Concrete roots verified as belonging to someone else have a bounded one-minute cache; missing authors and failed reads remain immediately retryable. The watcher publishes working, thinking, and typing presence from actual runtime activity using the authenticated REST endpoint. It stops refreshing when work finishes or is cancelled; the app clears the indicator through its expiry timer. Accepted coding tasks publish a short native plan first; the watcher sends one acknowledgement with up to three steps in the source thread or dedicated channel. Every runtime returns a distinct final answer for guarded watcher delivery. Plans and reconnects cannot duplicate or suppress that final answer.
+Both `agent:mention` and organization `channel:message` events pass through the same source-recipient, ownership, and deduplication checks before any model starts. The watcher hydrates compact roster entries through `get_agent`, subscribes only to the organization verified from that authenticated profile, and restores the subscription after reconnect. Organization `task:created` and `task:updated` events enter the same authoritative assignment verifier as targeted `task:assigned` events, so a task starts only after `get_ticket` confirms it is open and owned by this agent. Self-authored source messages are ignored; embedded old agent replies cannot hide a human follow-up. An explicit tag establishes durable ownership of that thread, so later human follow-ups remain addressed to the agent without another @mention. Messages redirected to another agent and unaddressed agent chatter stay silent, while a direct stand-down cancels queued/running work and releases ownership for that thread. Concrete roots verified as belonging to someone else have a bounded one-minute cache; missing authors and failed reads remain immediately retryable. The watcher publishes working, thinking, and typing presence from actual runtime activity using the authenticated REST endpoint. It stops refreshing when work finishes or is cancelled; the app clears the indicator through its expiry timer. Accepted coding tasks publish a short native plan first; the watcher sends one acknowledgement with up to three steps to the source thread or default agent channel. Every runtime returns a distinct final answer for guarded watcher delivery. Plans and reconnects cannot duplicate or suppress that final answer.
 
 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.
 
@@ -112,7 +112,7 @@ The helper `openvisio-agent push-pr-branch` accepts no arguments. It pushes only
 
 Authorization recovery checks paused repositories locally every two seconds and clears both policy and failed-revision state before live ticket verification. It does not need a new watcher or a new chat message. Updating the package still requires the running service to load the new version once.
 
-Fresh top-level messages belong in the agent’s dedicated channel; responses to existing requests stay in their source thread. The watcher resolves a unique exact identity/name match (including `agent-alex` and `alex-agent`) and never falls back to general. Use `connect ... --channel <id>` for a differently named dedicated channel. If it is missing or ambiguous, ticket results remain recorded and channel delivery stays pending; the watcher does not invent a channel-creation tool.
+Responses to existing requests stay in their source thread. Fresh top-level results use the agent’s dedicated channel by default; when a teammate explicitly requests a message in another named channel, the agent resolves that destination from live `list_channels` and posts there. The watcher resolves a unique exact identity/name match (including `agent-alex` and `alex-agent`) and never silently falls back to general. Use `connect ... --channel <id>` for a differently named dedicated channel. If a requested or default channel is missing or ambiguous, the agent reports that condition instead of inventing a channel or id.
 
 Codex, OpenCode, Gemini CLI, and Qwen Code use Mastra ACP directly. OpenCode starts only for an accepted cycle and exits as soon as that cycle releases it, so the idle watcher does not retain an OpenCode child process. Other runtimes retain work sessions per ticket in a six-entry pool and reply sessions in an eight-entry pool; their idle sessions expire after five minutes, and active sessions cannot be evicted. Git snapshots are asynchronous, lightweight commands lazily load the watcher, and logs separate queue wait, preflight, first-event, and total runtime time. Studio reads watcher liveness from the local PID lock instead of requiring journal heartbeats, and model changes arrive through filesystem notifications. Projects reconcile with concurrency three and enqueue tickets before reading optional activity history; later idle recovery reads activity only. Coordination sessions can update the board without gaining repository access.
 

package/USER_GUIDE.md

@@ -74,7 +74,7 @@ Stopping a watcher interrupts its active work. When you are ready to resume, run
 - **Assign repository work:** assign an actionable ticket to the agent in a project with a linked codebase. Include the problem, expected behavior, and how the result should be checked.
 - **Continue a conversation:** reply in the same thread. Keep follow-up instructions concrete, such as “The new test fails on an empty email address; please fix that case.”
 
-Replies stay in their source thread. New completion messages use the agent’s dedicated channel. Check the ticket and any linked pull request for delivered results. A progress message describes ongoing work; wait for the final result or blocker.
+Replies stay in their source thread. New completion messages use the agent’s dedicated channel by default. You can explicitly ask the agent to send or announce something in another named channel; it resolves that destination from the live channel list and confirms the action in the source thread. Check the ticket and any linked pull request for delivered results. A progress message describes ongoing work; wait for the final result or blocker.
 
 For accepted coding tasks, the agent starts by publishing a short plan. You receive one acknowledgement with up to three steps, followed later by its result. The agent can delegate independent pieces to native sub-agents and remains responsible for checking their work. Thinking, working, and typing indicators follow runtime activity; they expire after work stops. A reconnect does not repeat the plan or cancel healthy work.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openvisio-agent",
-  "version": "0.25.7",
+  "version": "0.25.8",
   "description": "Connect Claude Code, Codex, OpenCode, Gemini CLI, or Qwen Code to an OpenVisio team \u2014 MCP tools + optional autonomy \u2014 in one command.",
   "type": "module",
   "bin": {

package/scenarios/workspace.scenarios.mjs

@@ -16,18 +16,19 @@ async function eventually(predicate, description) {
   assert.fail(`Watcher did not reach: ${description}`)
 }
 
-export function fixture({ agent = 'codex', name, task = true, run, threadError = false, commentTools = [], onComment, selfProfile = self, listAgents, getTicket, listChannels, listActivity, transportRecoveryDelays, activityReporter } = {}) {
+export function fixture({ agent = 'codex', name, task = true, run, threadError = false, commentTools = [], onComment, selfProfile = self, listAgents, getAgent, getTicket, listChannels, listActivity, transportRecoveryDelays, activityReporter } = {}) {
   const dir = mkdtempSync(join(tmpdir(), 'byo-workspace-'))
   const posts = [], runs = [], calls = [], logs = [], messages = [], subscriptions = []
   const ticket = { id: 77, project_id: 1, slug: 'OPEN-77', title: 'Repair the component', agent_id: 7, status: 'In Progress', type_id: 1, updated_at: 'revision-1' }
   let watcher, connection, messageId = 100, closed = 0
   const memory = createByoMemoryGraph({ path: join(dir, 'ledger.json') })
   const mcp = {
-    listTools: async () => ['list_agents', 'list_projects', 'list_boards', 'list_tasks', 'get_ticket', 'update_ticket', 'post_message', 'list_message_thread', 'list_channels', 'list_task_types', 'list_activity', ...commentTools].map((name) => ({ name, ...(name === 'list_task_types' ? { inputSchema: { required: ['project_id', 'board_id'], properties: { project_id: {}, board_id: {} } } } : {}) })),
+    listTools: async () => ['list_agents', 'get_agent', 'list_projects', 'list_boards', 'list_tasks', 'get_ticket', 'update_ticket', 'post_message', 'list_message_thread', 'list_channels', 'list_task_types', 'list_activity', ...commentTools].map((name) => ({ name, ...(name === 'list_task_types' ? { inputSchema: { required: ['project_id', 'board_id'], properties: { project_id: {}, board_id: {} } } } : {}) })),
     callTool: async (name, args = {}) => {
       calls.push({ name, args })
       if (commentTools.includes(name)) return onComment ? await onComment(name, args) : { id: 500 }
       if (name === 'list_agents') return listAgents ? await listAgents() : { agents: [selfProfile] }
+      if (name === 'get_agent') { assert.equal(args.agent_id, Number(selfProfile.id)); return { agent: getAgent ? await getAgent(args.agent_id) : selfProfile } }
       if (name === 'list_projects') return { projects: [{ id: 1, name: 'Workspace' }] }
       if (name === 'list_tasks') return { tasks: task ? [{ ...ticket }] : [] }
       if (name === 'list_boards') return { boards: [{ id: 4 }] }

package/scripts/certify.mjs

@@ -56,6 +56,8 @@ const assertions = [
   ['idle watchers use event notifications without journal or settings polling', watcher.includes('watchFs(stateDir') && !watcher.includes('modelSettingsTimer') && !journal.includes("emit('runtime.heartbeat'")],
   ['ticket pickup precedes optional activity reads', watcher.indexOf("await handleTaskSignal('task:assigned'", watcher.indexOf('const reconcileBacklog')) < watcher.indexOf('await replayRecentActivity(projects)', watcher.indexOf('const reconcileBacklog'))],
   ['task:assigned is handled', watcher.includes("k === 'task:assigned'")],
+  ['task creation and update fanout use the assignment verifier', watcher.includes("k === 'task:created'") && watcher.includes("k === 'task:updated'") && watcher.includes('return handleTaskSignal(k, raw)')],
+  ['compact agent records are hydrated before organization subscription', watcher.includes("callMcpTool('get_agent', { agent_id: selfAgentId })") && watcher.includes('selfAgentId != null && selfOrganizationId == null')],
   ['task signals are verified with get_ticket', watcher.includes("callMcpTool('get_ticket'")],
   ['review and testing handoffs do not restart work', watcher.includes('taskIsAwaitingReview(task, reviewIds)') && watcher.includes('taskIsAwaitingReview(ticket, typeSets.review)')],
   ['review handoff releases the task key for future rework', watcher.includes('seenTasks.delete(taskKey)') && watcher.includes('seenTasks.delete(key)')],
@@ -79,7 +81,7 @@ const assertions = [
   ['generic coding pickup messages are absent', !watcher.includes("I've picked this up and will return here with the verified result")],
   ['human-facing ticket references require slugs, never database ids', watcher.includes('TICKET SLUGS, NEVER DATABASE IDS') && watcher.includes('ticketDisplaySlug(task)') && events.includes('export function ticketDisplaySlug') && !events.includes('I finished ticket #${task.id}')],
   ['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']") && codexConfig.includes('disabled_tools = [')],
+  ['guarded replies cannot race the watcher while explicit channel delivery remains available', watcher.includes("delivery?.watcherOwned && !delivery?.allowChannelMessaging") && watcher.includes('conversationRequestsChannelMessage(text)') && codexConfig.includes('disabled_tools = [')],
   ['ACP sessions receive the authenticated OpenVisio proxy', mastraHarness.includes("name: 'openvisio-team-watcher'") && mastraHarness.includes('OPENVISIO_CODEX_MCP_URL')],
   ['Codex discovers deferred OpenVisio actions before claiming they are missing', watcher.includes('Codex may defer MCP actions') && watcher.includes('use tool_search to find that exact action') && watcher.includes('initial-list miss is NOT evidence that the server is disconnected')],
   ['Codex authentication is injected outside the model', codexConfig.includes('OPENVISIO_CODEX_API_KEY') && codexProxy.includes('toolWithoutCredentialInputs') && codexProxy.includes('client.callTool') && watcher.includes('local OpenVisio MCP bridge injects authentication outside the model')],

package/src/events.mjs

@@ -565,6 +565,19 @@ export function conversationAsksPendingTickets(value) {
   return pending && question
 }
 
+// A guarded reply normally has post_message removed so the runtime cannot race
+// the watcher's single source-thread delivery. Keep that guard unless the human
+// explicitly asks the agent to publish into a named channel. The destination is
+// still resolved from live list_channels by the runtime; this only identifies
+// the narrow class of requests that needs the posting tool.
+export function conversationRequestsChannelMessage(value) {
+  const text = String(value || '')
+  const action = /\b(?:send|post|message|announce|notify|share|write)\b/i.test(text)
+  const channel = /#[a-z0-9][a-z0-9_-]*\b/i.test(text) || /\b(?:in|into|on|to)\s+(?:the\s+)?(?:channel\s+)?[a-z0-9][a-z0-9 _-]{0,80}\s+channel\b/i.test(text) || /\bchannel\s+(?:named\s+|called\s+)?["'`#]?[a-z0-9][a-z0-9 _-]*/i.test(text)
+  const negated = /\b(?:do\s+not|don't|dont|never)\s+(?:send|post|message|announce|notify|share|write)\b/i.test(text)
+  return action && channel && !negated
+}
+
 // Filing a ticket is a team mutation, even when its description asks for code.
 // Questions about a previous creation and negated requests stay read-only.
 export function conversationCreatesTicket(value) {

package/src/watch.mjs

@@ -10,7 +10,7 @@ import { fileURLToPath } from 'node:url'
 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 { buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, conversationAsksPendingTickets, conversationCreatesTicket, conversationNeedsCode, failedTaskRevisionIsCurrent, mentionDedupeKeys, messageParentId, messageSenderIsSelf, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskAgentIdentifier, taskBelongsToAgent, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
+import { buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, conversationAsksPendingTickets, conversationCreatesTicket, conversationNeedsCode, conversationRequestsChannelMessage, failedTaskRevisionIsCurrent, mentionDedupeKeys, messageParentId, messageSenderIsSelf, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskAgentIdentifier, taskBelongsToAgent, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
 import { WORK_SESSION_TOOL, workSessionRequest, agentProfileContext } from './runtime-control.mjs'
 import { createMastraMemory } from './memory.mjs'
 import { createContextService } from './context-service.mjs'
@@ -87,7 +87,7 @@ const REPLY_DISCIPLINE = [
   '  • LOOK UP ASSIGNED WORK. If someone says they assigned you a task, asks which task is yours, or asks for its status, check the live board yourself with list_projects + list_tasks and then get_ticket as needed. Use list_agents only if assignment data requires a numeric identity lookup. Match assignments to your authenticated agent identity. Do not ask the teammate for a project slug, ticket slug, or numeric id before trying those MCP tools; ask only if the live lookup fails or returns genuinely ambiguous matches.',
   '  • 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.',
   '  • 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.',
-  '  • NEW THREADS BELONG IN YOUR DEDICATED CHANNEL. Reply to an existing request in its original thread. For any fresh top-level thread (results, blockers, or an introduction), use only your own dedicated agent channel, resolved from live list_channels by your exact identity/name. Never open a fresh thread in general, a project channel, or another agent’s channel. If no unique dedicated channel exists, keep results on the ticket and report the missing channel in an existing source thread. Never invent a channel or tool.',
+  '  • HONOR CHANNEL DESTINATIONS. Reply to an existing request in its original thread. When a teammate explicitly asks you to send, post, announce, or share something in another channel, resolve that exact destination from live list_channels and post there. Use your dedicated agent channel for fresh top-level results, blockers, and introductions only when no other destination was requested. Never invent a channel id or silently substitute a different channel.',
   '  • WRITE PLAINLY. Prefer short sentences, commas, periods, and colons. Avoid em dashes except when reproducing quoted text.',
 ].join('\n')
 
@@ -944,15 +944,27 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   let selfRead = null
   let selfReadAfter = 0
   const ensureSelfAgent = async () => {
-    if (selfAgentId != null) return
+    if (selfAgentId != null && selfOrganizationId != null) return
     if (!selfRead && Date.now() < selfReadAfter) return
-    if (!selfRead) selfRead = callMcpTool('list_agents').then((result) => toolData(result, 'list_agents')).then((data) => {
-      const agents = Array.isArray(data.agents) ? data.agents : []
-      const identified = agents.find((row) => String(row?.identifier || row?.slug || '') === identifier)
-      const named = agents.filter((row) => !row?.identifier && !row?.slug && String(row?.name || '').trim().toLowerCase() === String(name || '').trim().toLowerCase())
-      const self = identified || (named.length === 1 ? named[0] : null)
-      rememberSelfAgent(self)
-    }).catch((error) => {
+    if (!selfRead) selfRead = (async () => {
+      if (selfAgentId == null) {
+        const data = toolData(await callMcpTool('list_agents'), 'list_agents')
+        const agents = Array.isArray(data.agents) ? data.agents : []
+        const identified = agents.find((row) => String(row?.identifier || row?.slug || '') === identifier)
+        const named = agents.filter((row) => !row?.identifier && !row?.slug && String(row?.name || '').trim().toLowerCase() === String(name || '').trim().toLowerCase())
+        rememberSelfAgent(identified || (named.length === 1 ? named[0] : null))
+      }
+      // Compact list_agents responses can contain only id + name. Hydrate that
+      // authenticated match so organization fanout can be subscribed without
+      // trusting organization data from an incoming event.
+      if (selfAgentId != null && selfOrganizationId == null) {
+        const names = await discoverMcpTools()
+        if (names.has('get_agent')) {
+          const detail = toolData(await callMcpTool('get_agent', { agent_id: selfAgentId }), 'get_agent')
+          rememberSelfAgent(detail.agent ?? detail.data?.agent ?? detail)
+        }
+      }
+    })().catch((error) => {
       log('Agent profile unavailable; continuing with task ownership and configured aliases: ' + (error?.message || error))
     }).finally(() => { selfRead = null; selfReadAfter = Date.now() + 60_000 })
     await selfRead
@@ -1132,7 +1144,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', sourceMessageId, allowCancelled = false, isCancelled = () => false }) => {
     if (stopping) throw new Error('Watcher is stopping')
     const deliveryKey = String(key || '')
-    if (parentId == null) {
+    if (parentId == null && !validBackendId(channelId)) {
       channelId = await projectStatusChannel(projectId)
       if (channelId == null) throw new Error('No dedicated agent channel available for a new thread')
       projectId = undefined // dedicated channels may be organization-scoped
@@ -1660,7 +1672,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const ticketWorktree = preparedWorkdir || (kind === 'full' && activeTaskRef ? findTicketWorktree(workdir, activeTaskRef.ticketId) : '')
     const runnerOptions = {
       cycleId: cycleControl.cycleId, attempt: cycleControl.attempt || 1,
-      ...(delivery?.watcherOwned ? { disabledMcpTools: ['post_message'] } : {}),
+      ...(delivery?.watcherOwned && !delivery?.allowChannelMessaging ? { disabledMcpTools: ['post_message'] } : {}),
       ...(ticketWorktree ? { workdir: ticketWorktree } : {}),
     }
     const targets = [...new Set(targetChannels.filter((id) => id != null && Number.isFinite(Number(id))).map(Number))]
@@ -2002,7 +2014,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
 
   function routeEvent(k, d) {
     const raw = d && typeof d === 'object' ? d : {}
-    if (k === 'task:assigned' || k === 'task:updated') {
+    if (k === 'task:created' || k === 'task:assigned' || k === 'task:updated') {
       return handleTaskSignal(k, raw)
     } else if (k === 'agent:mention') {
       const cid = raw.channel_id != null ? raw.channel_id : (raw.channelId != null ? raw.channelId : null)
@@ -2055,8 +2067,8 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       // Every runtime carries the source thread through the queue so a later
       // redirect can cancel its process. The watcher delivers the final answer
       // for every runtime after 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, sourceMessageId: mid, watcherOwned: true }
+      const conversationDelivery = (stage = 'reply', skipIfAnyAgentReply = stage !== 'result', allowChannelMessaging = false) => cid != null
+        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, sourceMessageId: mid, watcherOwned: true, allowChannelMessaging }
         : null
       // Under-the-hood model control from chat (view / switch the model the agent runs).
       const mcmd = cid != null ? parseModelCmd(text) : null
@@ -2086,6 +2098,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         return
       }
       const creatingTicket = conversationCreatesTicket(text)
+      const channelMessaging = !creatingTicket && conversationRequestsChannelMessage(text)
       const assignmentKey = controlKey ? `assignment-routing:${controlKey}` : ''
       const priorAssignment = assignmentKey ? memory.get(assignmentKey) : null
       const retryAssignment = priorAssignment?.state === 'failed' && /^\s*(?:please\s+)?(?:try\s+again|retry)(?:\s+please)?[.!?]*\s*$/i.test(text)
@@ -2121,10 +2134,10 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       // subsequent working/typing heartbeat for its lane.
       if (cid != null) sendStatus(cid, 'thinking')
       const codingMention = !creatingTicket && canCode && conversationNeedsCode(text, { rootContent: raw._threadRootContent })
-      const replyDelivery = conversationDelivery(codingMention ? 'result' : 'reply', !codingMention)
+      const replyDelivery = conversationDelivery(codingMention ? 'result' : 'reply', !codingMention, channelMessaging)
       let 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}".` : ''} Use additional discovery, resources, and history when they help answer this request.`
+          ? `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.'} ${channelMessaging ? 'The teammate explicitly requested a message in another channel. Use list_channels to resolve the named destination, then call post_message once with that exact channel_id. Do not substitute your dedicated or source channel for the requested destination. Return a short confirmation for the watcher to deliver in this source thread.' : '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}".` : ''} Use additional discovery, resources, and history when they help answer this request.`
           : `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)` : ''}, using the authenticated session bridge. 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.` : ''} Use additional discovery, resources, and history when they help answer this request.${codingMention ? ' Stop only after the work and final result/blocker.' : ' After your single reply, STOP.'}`
         : undefined
       if (ctx && creatingTicket) ctx += ' This is a ticket-creation request, not repository implementation. Discover create_ticket on the authenticated watcher server, resolve the project, board, and valid type using list_projects, list_boards, and list_task_types, then create the requested ticket once. Follow its actual schema. If a required detail is ambiguous, ask for that detail rather than inventing it. Report the returned ticket reference. Never replay a creation after a timeout or uncertain response.'
@@ -2134,7 +2147,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         // 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(creatingTicket ? 'coord' : 'fast', ctx, cid == null ? [] : [cid], null, replyDelivery)
+      } else void drain(creatingTicket || channelMessaging ? 'coord' : 'fast', ctx, cid == null ? [] : [cid], null, replyDelivery)
     } else if (k === 'error') {
       const detail = raw && (raw.message || raw.error || raw.reason || raw.code || raw.d?.message || raw.d?.error)
       log('error event: ' + (detail ? String(detail) : JSON.stringify(raw)).slice(0, 220))
@@ -2159,6 +2172,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       activity.pulse()
       emit('connection.connected', { status: 'connected' })
       for (const wake of [...recoveryWaiters]) wake()
+      queueMicrotask(() => { if (!stopping) void ensureSelfAgent() })
       if (autoStart) setTimeout(() => { if (!stopping) void reconcileBacklog() }, 250)
     }, log })