openvisio-agent 0.25.6 → 0.25.8

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## 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.
+- Cache projects during connection recovery, then check only `list_activity` every 30 seconds while idle. The lightweight check does not rescan projects, tasks, boards, or task types and starts no model provider unless it finds a new addressed message.
+- Add a behavioral regression test proving a missed mention is handled once without idle project or task scans.
+
 ## [0.25.6] — 2026-09-21
 
 - Keep healthy backend watchers event-driven after their connection recovery pass instead of polling every project for tasks and activity every 30 seconds.

package/README.md

@@ -81,13 +81,13 @@ The integration follows Mastra's [semantic memory](https://mastra.ai/docs/memory
 
 Model selections are stable. Exact IDs (including reasoning effort) are preserved. An unsuffixed ACP model may resolve once to the same model with `medium` effort; the watcher saves that exact selection. Unavailable selections produce an explicit error rather than switching generations or families. Claude versioned IDs are preserved, with automatic family fallbacks disabled. Codex uses the configured chat model for replies.
 
-Backend/BYO watchers reconcile once whenever the WebSocket starts or reconnects. 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. Team discovery is shared by every runtime provider: structured MCP results and compact Markdown list envelopes are normalized once before the watcher resolves its project, identity, boards, tickets, or dedicated channel. Adding another model provider therefore reuses the same saved team connection and setup path instead of adding provider-specific project discovery. Optional actions such as ticket comments are used only when advertised; their absence cannot strand a completed ticket in a retry loop. After the recovery pass, the healthy event connection waits without polling MCP tools and starts a model only when work arrives.
+Backend/BYO watchers reconcile assignments whenever the WebSocket starts or reconnects. 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 work missed while offline. Because the backend can omit an addressed message from the watcher stream, the watcher retains the recovered project IDs and checks only recent `list_activity` every 30 seconds; it does not repeat project, board, task-type, or task scans while idle. Team discovery is shared by every runtime provider: structured MCP results and compact Markdown list envelopes are normalized once before the watcher resolves its project, identity, boards, tickets, or dedicated channel. Adding another model provider therefore reuses the same saved team connection and setup path instead of adding provider-specific project discovery. Optional actions such as ticket comments are used only when advertised; their absence cannot strand a completed ticket in a retry loop. The activity check starts a model only when it finds a new addressed message.
 
 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 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,9 +112,9 @@ 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. Coordination sessions can update the board without gaining repository access.
+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.
 
 Assignments use independent FIFO entries with stable-key duplicate suppression and bounded, worktree-aware concurrency. Backlog recovery uses the same ticket verification path as WebSocket events, and each queued ticket is checked again before a model starts. MCP calls have a 20-second deadline including response bodies; tool discovery is cached and paginated. Codex MCP failures retain a bounded, credential-redacted reason in the watcher log. Cancellation targets only its ACP session. Credentials and replay state use atomic file replacement; Mastra persists contextual memory in libSQL.
 

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.6",
+  "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, 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 }] }
@@ -36,7 +37,7 @@ export function fixture({ agent = 'codex', name, task = true, run, threadError =
       if (name === 'update_ticket') { Object.assign(ticket, args); return { ticket: { ...ticket } } }
       if (name === 'list_channels' && listChannels) return { channels: await listChannels() }
       if (name === 'list_channels') return { channels: [{ id: 2, name: 'alex', agent_id: 7 }, { id: 9, name: 'general' }] }
-      if (name === 'list_activity') return { activities: [] }
+      if (name === 'list_activity') return listActivity ? await listActivity(args) : { activities: [] }
       if (name === 'list_message_thread') {
         if (typeof threadError === 'function') await threadError()
         else if (threadError) throw new Error('Thread service unavailable')

package/scripts/certify.mjs

@@ -52,10 +52,12 @@ const assertions = [
   ['new follow-ups only deduplicate later replies', watcher.includes('repliesAfterSource(renderedAgentMessages') && watcher.includes('sourceMessageId: mid')],
   ['Mastra snapshots do not block the event loop', mastraHarness.includes('await execFileAsync') && !mastraHarness.includes('spawnSync')],
   ['OpenCode exits after work while the event watcher stays idle', runtimeProviders.includes("id: 'opencode'") && runtimeProviders.includes('idleSessionMs: 0') && watcher.includes('idleMs: runtimeIdleMs')],
-  ['healthy backend watchers do not poll projects while idle', watcher.includes('onConnect: () =>') && watcher.includes('void reconcileBacklog()') && !watcher.includes('taskProbeTimer') && !watcher.includes('taskProbeStartTimer')],
+  ['healthy backend watchers recover missed messages without polling projects or tasks while idle', watcher.includes('onConnect: () =>') && watcher.includes('void reconcileBacklog()') && watcher.includes('activityRecoveryTimer') && watcher.includes('replayRecentActivity(knownProjects)') && !watcher.includes('taskProbeTimer') && !watcher.includes('taskProbeStartTimer')],
   ['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("const activityData = await callMcpTool", watcher.indexOf('const reconcileBacklog'))],
+  ['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')
 
@@ -898,6 +898,8 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   // hoping poll_inbox re-surfaces the same item. Each queue entry retains that
   // source independently through work, continuation, and delivery.
   let backlogProbeBusy = false
+  let activityProbeBusy = false
+  let knownProjects = []
   let selfAgentId = null
   let selfOrganizationId = null
   let identityContext = memory.get?.(`identity:${identifier}`)?.meta?.context || agentProfileContext({}, identifier)
@@ -942,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
@@ -1130,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
@@ -1424,6 +1438,87 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     return publishBlocker({ prompt, taskRef, delivery, notice, ticketNotice, pause: true })
   }
 
+  const replayRecentActivity = async (projects) => {
+    const mentionActivity = []
+    let activityReplayTouched = false
+    await ensureSelfAgent()
+    const mentionNeedles = [...selfAliases].map((alias) => '@' + alias)
+    await mapConcurrent(projects, 3, async (project) => {
+      const activityData = await callMcpTool('list_activity', { project_id: project.id }).then(toolData).catch((error) => {
+        log('activity reconciliation unavailable: ' + (error?.message || error))
+        return {}
+      })
+      const activities = Array.isArray(activityData.activities) ? activityData.activities : Array.isArray(activityData.activity) ? activityData.activity : []
+      for (const item of activities) {
+        const text = JSON.stringify(item)
+        const activityKey = String(project.id) + ':' + String(item.id ?? item.message_id ?? item.messageId ?? text.slice(0, 500))
+        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()
+        const activityChannelId = item?.channel_id ?? item?.channelId ?? data?.channel_id ?? data?.channelId
+        const activityMessageId = activityMessage?.id ?? activityMessage?.message_id ?? activityMessage?.messageId
+        const activityParentId = messageParentId(activityMessage)
+        const activityThreadRoot = activityParentId != null ? activityParentId : activityMessageId
+        const activityControlKey = threadControlKey(activityChannelId, activityThreadRoot)
+        const ownedActivity = !!activityControlKey && memory.has(activityControlKey, 'active')
+        // Search only the source message, never the whole activity envelope: an
+        // old tagged thread root can otherwise make another agent's new reply
+        // look addressed to this watcher. Explicit mentions and human follow-ups
+        // in a persistently owned thread both enter the guarded per-message path.
+        const addressedActivity = mentionNeedles.some((needle) => activityText.includes(needle)) || ownedActivity || activityParentId != null
+        if (!seenActivities.has(activityKey) && addressedActivity && /message|mention|channel/i.test(text)) {
+          seenActivities.add(activityKey); trimSeen(seenActivities); activityReplayTouched = true
+          // The same logical mention may already have arrived over WebSocket.
+          // Share the id/signature guard instead of starting a second model turn.
+          // Recover the former pre-routing acknowledgement bug exactly once
+          // when an owned-thread source has no received ledger entry.
+          if (markMentionHandled(activityMessage, activityChannelId)) {
+            const activityMentionKeys = mentionDedupeKeys(activityMessage, activityChannelId)
+            const activitySourceKey = `mention:${activityChannelId ?? '?'}:${activityMentionKeys.idKey || activityMentionKeys.signatureKey || activityThreadRoot}`
+            if (memory.has(activitySourceKey, 'received')) continue
+          }
+          mentionActivity.push({
+            projectId: project.id,
+            project: project.name,
+            channelId: activityChannelId,
+            message: activityMessage,
+            activity: item, activityKey,
+          })
+        }
+      }
+    })
+    if (activityReplayTouched) persistReplay()
+    if (!mentionActivity.length) return
+    log('activity recovery found ' + mentionActivity.length + ' mention(s) -> guarded reply cycle(s)')
+    // Replay each real message through the exact same delivery path as a live
+    // WebSocket mention. This preserves thread ids and lets postMessageOnce
+    // consult the rendered thread before any reply is emitted.
+    for (const mention of mentionActivity) {
+      void onEvent('agent:mention', {
+        project_id: mention.projectId,
+        channel_id: mention.channelId,
+        message: mention.message,
+        _mentionAlreadyMarked: true,
+      })?.then((result) => {
+        if (result?.status === 'retry') { seenActivities.delete(mention.activityKey); persistReplay() }
+      })
+    }
+  }
+
+  // The backend can occasionally omit a targeted WebSocket message. Keep a
+  // cached project list from connection recovery and check only recent activity
+  // while idle. This does not scan projects, boards, task types, or tickets and
+  // does not start a provider process unless a new addressed message is found.
+  const reconcileActivity = async () => {
+    if (stopping || !mcpUrl || backlogProbeBusy || activityProbeBusy || !knownProjects.length) return
+    activityProbeBusy = true
+    try { await replayRecentActivity(knownProjects) }
+    catch (e) { log('activity recovery failed: ' + (e?.message || e)) }
+    finally { activityProbeBusy = false }
+  }
+
   // Reconcile everything that may have arrived while disconnected. This spends no
   // model tokens unless the tools actually report pending work.
   const reconcileBacklog = async () => {
@@ -1433,8 +1528,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     try {
       const projectsData = toolData(await callMcpTool('list_projects'), 'list_projects')
       const projects = Array.isArray(projectsData.projects) ? projectsData.projects : []
-      const mentionActivity = []
-      let activityReplayTouched = false
+      knownProjects = projects.map((project) => ({ id: project.id, name: project.name }))
       await mapConcurrent(projects, 3, async (project) => {
         try {
           const assigned = []
@@ -1484,71 +1578,9 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
             seenTasks.delete(key)
             await handleTaskSignal('task:assigned', { task: { id: next.id, project_id: next.projectId } })
           }
-          const activityData = await callMcpTool('list_activity', { project_id: project.id }).then(toolData).catch((error) => {
-            log('activity reconciliation unavailable: ' + (error?.message || error))
-            return {}
-          })
-          const activities = Array.isArray(activityData.activities) ? activityData.activities : Array.isArray(activityData.activity) ? activityData.activity : []
-          await ensureSelfAgent()
-          const mentionNeedles = [...selfAliases].map((alias) => '@' + alias)
-          for (const item of activities) {
-            const text = JSON.stringify(item)
-            const activityKey = String(project.id) + ':' + String(item.id ?? item.message_id ?? item.messageId ?? text.slice(0, 500))
-            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()
-            const activityChannelId = item?.channel_id ?? item?.channelId ?? data?.channel_id ?? data?.channelId
-            const activityMessageId = activityMessage?.id ?? activityMessage?.message_id ?? activityMessage?.messageId
-            const activityParentId = messageParentId(activityMessage)
-            const activityThreadRoot = activityParentId != null ? activityParentId : activityMessageId
-            const activityControlKey = threadControlKey(activityChannelId, activityThreadRoot)
-            const ownedActivity = !!activityControlKey && memory.has(activityControlKey, 'active')
-            // Search only the source message, never the whole activity envelope: an
-            // old tagged thread root can otherwise make another agent's new reply
-            // look addressed to this watcher. Explicit mentions and human follow-ups
-            // in a persistently owned thread both enter the guarded per-message path.
-            const addressedActivity = mentionNeedles.some((needle) => activityText.includes(needle)) || ownedActivity || activityParentId != null
-            if (!seenActivities.has(activityKey) && addressedActivity && /message|mention|channel/i.test(text)) {
-              seenActivities.add(activityKey); trimSeen(seenActivities); activityReplayTouched = true
-              // The same logical mention may already have arrived over WebSocket.
-              // Share the id/signature guard instead of starting a second model turn.
-              // Recover the former pre-routing acknowledgement bug exactly once
-              // when an owned-thread source has no received ledger entry.
-              if (markMentionHandled(activityMessage, activityChannelId)) {
-                const activityMentionKeys = mentionDedupeKeys(activityMessage, activityChannelId)
-                const activitySourceKey = `mention:${activityChannelId ?? '?'}:${activityMentionKeys.idKey || activityMentionKeys.signatureKey || activityThreadRoot}`
-                if (memory.has(activitySourceKey, 'received')) continue
-              }
-              mentionActivity.push({
-                projectId: project.id,
-                project: project.name,
-                channelId: activityChannelId,
-                message: activityMessage,
-                activity: item, activityKey,
-              })
-            }
-          }
         } catch (error) { log('Project reconciliation failed: ' + (error?.message || error)) }
       })
-      if (activityReplayTouched) persistReplay()
-      if (mentionActivity.length) {
-        log('backlog reconciliation found ' + mentionActivity.length + ' mention(s) -> guarded reply cycle(s)')
-        // Replay each real message through the exact same delivery path as a live
-        // WebSocket mention. This preserves thread ids and lets postMessageOnce
-        // consult the rendered thread before any reply is emitted.
-        for (const mention of mentionActivity) {
-          void onEvent('agent:mention', {
-            project_id: mention.projectId,
-            channel_id: mention.channelId,
-            message: mention.message,
-            _mentionAlreadyMarked: true,
-          })?.then((result) => {
-            if (result?.status === 'retry') { seenActivities.delete(mention.activityKey); persistReplay() }
-          })
-        }
-      }
+      await replayRecentActivity(projects)
     } catch (e) {
       log('backlog reconciliation failed: ' + (e && e.message ? e.message : e))
     } finally { backlogProbeBusy = false }
@@ -1640,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))]
@@ -1982,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)
@@ -2035,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
@@ -2066,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)
@@ -2101,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.'
@@ -2114,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))
@@ -2139,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 })
 
@@ -2189,6 +2223,10 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   }
   const deliveryTimer = autoStart ? setInterval(() => void flushPendingReplies(), 30_000) : null
   deliveryTimer?.unref?.()
+  const activityRecoveryTimer = autoStart ? setInterval(() => {
+    if (!stopping) void trackOperation(reconcileActivity())
+  }, 30_000) : null
+  activityRecoveryTimer?.unref?.()
   const authorizationTimer = autoStart ? setInterval(() => void resumeReadyAuthorizations(), 2_000) : null
   authorizationTimer?.unref?.()
   let modelSettingsWatcher = null
@@ -2228,6 +2266,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     closePromise = (async () => {
       clearInterval(authorizationTimer)
       clearInterval(deliveryTimer)
+      clearInterval(activityRecoveryTimer)
       modelSettingsWatcher?.close()
       if (introTimer) clearTimeout(introTimer)
       try { handle?.close() } catch { /* already disconnected */ }
@@ -2252,6 +2291,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   }
   return {
     done, close, receive: onEvent, reconcile: () => stopping ? Promise.resolve() : trackOperation(reconcileBacklog()),
+    recoverActivity: () => stopping ? Promise.resolve() : trackOperation(reconcileActivity()),
     resumeAuthorizations: resumeReadyAuthorizations, retryDeliveries: flushPendingReplies,
     get pending() { return queues.work.size + queues.reply.size + mentionIntake.size },
   }