openvisio-agent 0.25.7 → 0.25.9

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## [0.25.9] — 2026-09-21
+
+- Keep pending-ticket detection within one sentence or clause, preventing a peer's ticket-status statement from hijacking a separate onboarding question.
+- Let BYO agents answer concrete peer questions and requests in an owned thread without requiring every turn to repeat an @mention.
+- Keep routine agent chatter silent and instruct peer replies to finish decisively instead of creating automated reply loops.
+- Route new comments on an assigned task through authoritative ownership checks and post one deduplicated reply in the source comment thread, including concrete requests from another BYO agent.
+- Remove the 30-second activity-feed recovery timer and startup `list_activity` pass. Healthy watchers now remain on WebSocket delivery while idle, with MCP recovery limited to connection and outstanding-delivery events.
+
+## [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

@@ -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 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.
+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`, and `list_task_types` to recover assigned work after a connection event. The authenticated profile lookup also supplies the verified organization needed for channel, assignment, and task-comment subscriptions. Once connected, the watcher makes no periodic `list_activity`, roster, project, board, task-type, or task calls while idle; incoming WebSocket events start the relevant verification path. 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. New comments on a task assigned to the agent are verified with `get_ticket`; human comments and concrete peer-agent requests receive one deduplicated reply in the source comment thread. Optional comment actions are used only when advertised, and their absence cannot strand a completed ticket in a retry loop.
 
 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. Another BYO agent can continue that owned thread with a concrete question or request without repeating the mention; routine agent status chatter remains silent to prevent reply loops. Ticket-inventory intent is sentence-scoped, so a peer saying it has no assigned tickets cannot hijack a separate onboarding or coordination question. Messages redirected to another agent 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,9 @@ 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.
+
+BYO agents can coordinate directly in a shared thread. Mention an agent once to establish the conversation; concrete peer questions and requests can continue there without repeating the mention. Routine agent status messages do not trigger replies, which prevents automated conversations from looping.
 
 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.9",
   "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/routing.scenarios.mjs

@@ -39,7 +39,7 @@ const recipientCases = [
   ['shared-request', '@Alex and @Atlas please review this.', 'handle'],
   ['explicit-shared-request', '@Alex and @Atlas can you both fix this?', 'handle'],
   ['delegation-through-self', '@Alex ask @Atlas to review this.', 'handle'],
-  ['mention-in-email', 'Please send the update to contact@alex.', 'follow-up'],
+  ['mention-in-email', 'Please send the update to contact@alex.', 'peer-follow-up'],
   ['email-to-other-person', 'Please use daniel@atlas.example for contact.', 'follow-up'],
   ['longer-handle', '@Alexandra please review.', 'ignore'],
   ['dotted-different-handle', '@Alex.morgan please review.', 'ignore'],
@@ -50,6 +50,7 @@ for (const [caseId, content, policy] of recipientCases) {
   for (const [senderId, sender, agent] of senders) {
     for (const owned of [false, true]) {
       const expected = policy === 'follow-up' ? (!agent && owned ? 'handle' : 'ignore')
+        : policy === 'peer-follow-up' ? (owned ? 'handle' : 'ignore')
         : policy === 'stop-follow-up' ? (!agent && owned ? 'stand_down' : 'ignore') : policy
       add(`recipient-${caseId}-${senderId}-${owned ? 'owned' : 'unowned'}`, 'recipient', `${caseId}: ${senderId} in ${owned ? 'an owned' : 'an unowned'} thread must ${expected}.`, () => {
         assert.equal(classifyConversationTarget({ id: 101, parent_id: 100, content, ...sender }, aliases, { threadOwned: owned }).action, expected)
@@ -219,6 +220,11 @@ add('completed-ticket-status-does-not-reopen', 'assignment-intent', 'A status qu
   await routeAssignments({ request: { slugs: ['OPEN-77'] }, loadTickets: async () => [{ id: 77, projectId: 1, slug: 'OPEN-77', status: 'Done' }], handleTask: async () => { dispatched++ } })
   assert.equal(dispatched, 0)
 })
+add('peer-onboarding-does-not-become-ticket-inventory', 'assignment-intent', 'A peer onboarding statement and later coordination question are not combined into a pending-ticket request.', () => {
+  const text = 'I currently have zero assigned tickets. Which repos are mine, and where do routine updates get posted?'
+  assert.equal(conversationAsksPendingTickets(text), false)
+  assert.equal(classifyConversationTarget({ content: text, senderAgent: { id: 9 } }, aliases, { threadOwned: true }).reason, 'owned-peer-follow-up')
+})
 
 const ticketStates = [
   ['actionable', { status: 'In Progress' }, true],

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 }] }
@@ -90,6 +91,10 @@ export function fixture({ agent = 'codex', name, task = true, run, threadError =
       messages.push(message)
       await watcher.receive('agent:mention', { channel_id: channel, message })
     },
+    async taskComment(content, { id = 300, parent, sender = human, projectId = 1, taskId = 77 } = {}) {
+      const comment = { id, task_id: taskId, content, taskSender: sender, ...(parent != null ? { parent_id: parent } : {}) }
+      await watcher.receive('task:comment', { project_id: projectId, task_id: taskId, comment })
+    },
     async cleanup() { await watcher.close(); rmSync(dir, { recursive: true, force: true }) },
   }
 }

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 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')],
+  ['healthy backend watchers do not poll MCP activity while idle', watcher.includes('onConnect: () =>') && watcher.includes('void reconcileBacklog()') && !watcher.includes('activityRecoveryTimer') && !watcher.includes('replayRecentActivity') && !watcher.includes("callMcpTool('list_activity'") && !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('await replayRecentActivity(projects)', watcher.indexOf('const reconcileBacklog'))],
+  ['connection recovery scans assignments without an activity-feed pass', watcher.includes('const reconcileBacklog') && watcher.includes("await handleTaskSignal('task:assigned'") && !watcher.includes('reconcileActivity')],
   ['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)')],
@@ -63,15 +65,16 @@ const assertions = [
   ['agent results are delivered independently of ticket completion', watcher.includes('agentFinal: true') && watcher.includes('pendingAgentResults')],
   ['completion delivery survives reconnect and deduplicates', watcher.includes('pendingCompletionReports: [...pendingCompletionReports]') && watcher.includes('reportedCompletions: [...reportedCompletions]') && watcher.includes('reportedCompletions.has(report.key)')],
   ['optional ticket comments cannot block verified completion', watcher.includes('callOptionalTicketComment({ projectId, ticketId, content: report.content })') && watcher.includes('no ticket comment tool is exposed; completing ticket') && watcher.includes('reportedTaskComments: [...reportedTaskComments]') && watcher.includes('reportedTaskComments.has(report.key)')],
-  ['ticket comments prefer the advertised modern schema with legacy compatibility', watcher.includes("names.has('create_task_comment') ? 'create_task_comment' : names.has('comment_ticket') ? 'comment_ticket' : ''") && watcher.includes("name === 'create_task_comment' ? { content } : { text: content }")],
+  ['ticket comments prefer the advertised modern schema with legacy compatibility', watcher.includes("names.has('create_task_comment') ? 'create_task_comment' : names.has('comment_ticket') ? 'comment_ticket' : ''") && watcher.includes("name === 'create_task_comment'") && watcher.includes("{ parent_id: Number(parentId) }") && watcher.includes("{ text: content }")],
   ['uncertain comment writes never trigger duplicate alternate ticket writes', watcher.includes('never try another comment endpoint after an error') && watcher.includes('no alternate ticket write will be attempted') && !watcher.includes("reason: 'not-available'")],
   ['ticket comments cannot masquerade as channel completion', events.includes("didChannelMessage: completed && mcpTool === 'post_message'") && watcher.includes('result.didChannelMessage')],
   ['single-watcher acquisition is atomic and fails closed', watcher.includes("openSync(lockPath, 'wx')") && watcher.includes('Could not acquire the single-watcher lock')],
-  ['websocket and activity mention delivery share a replay guard', watcher.includes('markMentionHandled(activityMessage, activityChannelId)') && watcher.includes('markMentionHandled(msg, cid)') && watcher.includes('recentMentionSignatures')],
-  ['reconciled mentions reuse the guarded websocket delivery path', watcher.includes("onEvent('agent:mention'") && watcher.includes('_mentionAlreadyMarked: true')],
-  ['conversation wake events preserve owned-thread follow-ups and filter other recipients before model start', watcher.includes("memory.has(controlKey, 'active')") && watcher.includes('classifyConversationTarget(msg, [...selfAliases], { threadOwned })') && events.includes("reason: 'owned-thread-follow-up'") && events.includes("reason: 'explicit-other-recipient'") && events.includes("reason: 'other-agent-chatter'")],
+  ['websocket mention delivery uses a persistent replay guard', watcher.includes('markMentionHandled(msg, cid)') && watcher.includes('recentMentionSignatures')],
+  ['conversation wake events preserve owned-thread follow-ups and filter other recipients before model start', watcher.includes("memory.has(controlKey, 'active')") && watcher.includes('classifyConversationTarget(msg, [...selfAliases], { threadOwned })') && events.includes("'owned-thread-follow-up'") && events.includes("reason: 'explicit-other-recipient'") && events.includes("reason: 'other-agent-chatter'")],
+  ['owned threads admit concrete peer requests without opening agent chatter loops', events.includes("reason: peerFollowUp ? 'owned-peer-follow-up'") && watcher.includes('This request was authored by another team agent') && watcher.includes('do not append a reciprocal question')],
+  ['pending-ticket intent is scoped to one clause', events.includes("text.split(/(?<=[.!?])") && events.includes('return tasks && pending && question')],
   ['prematurely acknowledged owned-thread replies recover exactly once', watcher.includes("!threadOwned || memory.has(sourceKey, 'received')") && watcher.includes('agent:mention replay recovered for active owned thread')],
-  ['reconciliation recovers untagged human follow-ups in owned threads', watcher.includes("memory.has(activityControlKey, 'active')") && watcher.includes('const addressedActivity = mentionNeedles.some') && watcher.includes("memory.has(activitySourceKey, 'received')")],
+  ['task comments use assigned-ticket verification and watcher-owned threaded delivery', watcher.includes("k === 'task:comment'") && watcher.includes('taskCommentFromEvent(raw)') && watcher.includes('postTaskCommentOnce') && watcher.includes("surface: 'task-comment'") && watcher.includes("['post_message', 'create_task_comment', 'comment_ticket']")],
   ['coding mentions require an action and concrete repository target', watcher.includes('conversationNeedsCode(text, { rootContent:') && events.includes('const action =') && events.includes('const target =')],
   ['agent-authored roots establish ownership and unaddressed legacy roots are verified before routing', watcher.includes('saveOwnThread(channelId, postedId, message)') && watcher.includes('const context = resolveOwnThread(cid, parent)') && watcher.includes('})]) : await context') && watcher.includes('_threadRootContent: rootContent')],
   ['stand-down and redirects cancel only source-thread workers', watcher.includes('cancelThread(cid, threadRoot') && watcher.includes('item.control.cancelled = true') && watcher.includes('item.control.runner?.cancelCurrent') && watcher.includes("subtype === 'canceled'")],
@@ -79,7 +82,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)') && watcher.includes("delivery?.surface === 'task-comment'") && 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

@@ -21,6 +21,23 @@ export function taskFromEvent(payload) {
   return null
 }
 
+// Task-comment events use the same rolling envelope variants as task events,
+// with the comment itself nested under `comment`. Keep transport normalization
+// in one place so the watcher can make ownership and sender decisions from a
+// stable shape.
+export function taskCommentFromEvent(payload) {
+  if (!payload || typeof payload !== 'object') return null
+  const envelopes = [payload, payload.data, payload.payload].filter((value) => value && typeof value === 'object' && !Array.isArray(value))
+  const source = Object.assign({}, ...envelopes.slice().reverse())
+  const comment = envelopes.map((value) => value.comment).find((value) => value && typeof value === 'object' && !Array.isArray(value))
+  if (!comment) return null
+  return {
+    projectId: source.project_id ?? source.projectId ?? comment.project_id ?? comment.projectId ?? null,
+    taskId: source.task_id ?? source.taskId ?? comment.task_id ?? comment.taskId ?? null,
+    comment,
+  }
+}
+
 export function taskAgentId(task) {
   if (!task || typeof task !== 'object') return null
   return task.agent_id ?? task.agentId ?? task.agent?.id ?? task.assigned_agent?.id ?? task.assignedAgent?.id ?? null
@@ -397,8 +414,8 @@ export function normalizeRenderedMessageText(value) {
 
 export function messageSenderIsSelf(row, identity = {}) {
   if (!row || typeof row !== 'object') return false
-  const sender = [row.sender, row.user, row.author, row.member].find((item) => item && typeof item === 'object') || {}
-  const expanded = [row.senderAgent, row.sender_agent, row.agent, sender.agent].find((item) => item && typeof item === 'object')
+  const sender = [row.taskSender, row.task_sender, row.sender, row.user, row.author, row.member].find((item) => item && typeof item === 'object') || {}
+  const expanded = [row.taskSenderAgent, row.task_sender_agent, row.senderAgent, row.sender_agent, row.agent, sender.agent].find((item) => item && typeof item === 'object')
   const senderKind = String(sender.type ?? sender.kind ?? sender.sender_type ?? row.sender_type ?? row.author_type ?? '').toLowerCase()
   const senderLooksLikeAgent = agentSenderKind(senderKind) || (!humanSenderKind(senderKind) && (sender.agent_id != null || sender.identifier != null || (sender.slug != null && !sender.email)))
   const agent = expanded || (senderLooksLikeAgent ? sender : {})
@@ -484,8 +501,8 @@ function conversationMentions(value, selfAliases) {
 
 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, m.member].find((item) => item && typeof item === 'object') || {}
+  if (m.taskSenderAgent || m.task_sender_agent || m.senderAgent || m.sender_agent || m.agent || m.agent_id != null || m.sender_agent_id != null || m.senderAgentId != null) return true
+  const sender = [m.taskSender, m.task_sender, m.sender, m.user, m.author, m.member].find((item) => item && typeof item === 'object') || {}
   if (sender.agent && typeof sender.agent === 'object') return true
   const kind = String(sender.type ?? sender.kind ?? sender.sender_type ?? m.sender_type ?? m.author_type ?? '').toLowerCase()
   return agentSenderKind(kind) || (!humanSenderKind(kind) && (sender.agent_id != null || sender.identifier != null || (sender.slug != null && !sender.email)))
@@ -506,7 +523,17 @@ export function classifyConversationTarget(message, selfAliases, { threadOwned =
 
   if (!text) return { action: 'ignore', reason: 'empty-message', text, explicitSelf, otherMentions: [] }
 
-  if (messageSenderIsAgent(m) && !explicitSelf) {
+  // A peer agent may continue a conversation without repeating @name on every
+  // turn. Admit only a concrete question or request in a thread this watcher
+  // already owns; routine agent status chatter remains silent. This keeps BYO
+  // collaboration usable without turning every shared-channel post into an
+  // agent-to-agent reply loop.
+  const peerFollowUp = messageSenderIsAgent(m) && !explicitSelf && threadOwned && (
+    /\?/.test(text) ||
+    /\b(?:can|could|would|will|do|did|are|have)\s+you\b/i.test(text) ||
+    /^\s*(?:thanks[,!.]?\s+)?(?:please\s+)?(?:review|check|confirm|explain|share|send|post|help|continue|take|handle|onboard)\b/i.test(text)
+  )
+  if (messageSenderIsAgent(m) && !explicitSelf && !peerFollowUp) {
     return { action: 'ignore', reason: 'other-agent-chatter', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
   }
   if (!explicitSelf && otherMentions.length) {
@@ -531,7 +558,7 @@ export function classifyConversationTarget(message, selfAliases, { threadOwned =
   // chatter were handled above and still fail closed.
   if (!explicitSelf) {
     if (threadOwned) {
-      return { action: 'handle', reason: 'owned-thread-follow-up', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
+      return { action: 'handle', reason: peerFollowUp ? 'owned-peer-follow-up' : 'owned-thread-follow-up', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
     }
     return { action: 'ignore', reason: 'unaddressed-thread-activity', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
   }
@@ -557,12 +584,30 @@ export function conversationNeedsCode(value, { rootContent = '' } = {}) {
 
 export function conversationAsksPendingTickets(value) {
   // Project prefixes such as OPEN-77 are identifiers, not the word “open”.
-  // A question about a finished ticket must not become a backlog pickup.
+  // A question about a finished ticket must not become a backlog pickup. Keep
+  // all three signals in the same sentence/clause so an onboarding message that
+  // states "I have zero assigned tickets" and later asks about team cadence does
+  // not get hijacked into the pending-ticket shortcut.
   const text = String(value || '').replace(/\b[a-z][a-z0-9]*-\d+\b/gi, '').replace(/\s+/g, ' ').trim()
-  if (!/\b(?:ticket|tickets|task|tasks)\b/i.test(text)) return false
-  const pending = /\b(?:pending|open|assigned|backlog|outstanding|in[ -]?progress|working on)\b/i.test(text)
-  const question = /\?|\b(?:any|what|which|how many|do you|have you|are there|show|list|check|verify|asked|whether)\b/i.test(text)
-  return pending && question
+  return text.split(/(?<=[.!?])\s+|[;\n]+/).some((clause) => {
+    const tasks = /\b(?:ticket|tickets|task|tasks)\b/i.test(clause)
+    const pending = /\b(?:pending|open|assigned|backlog|outstanding|in[ -]?progress|working on)\b/i.test(clause)
+    const question = /\?|\b(?:what|which|how many|do you|have you|are there|show|list|check|verify|tell me|asked|whether|can you|could you|would you)\b/i.test(clause)
+    return tasks && 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.

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, messageSenderIsAgent, messageSenderIsSelf, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskAgentIdentifier, taskBelongsToAgent, taskCommentFromEvent, 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')
 
@@ -732,9 +732,18 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     }),
     reply: createCycleQueue({
       concurrency: 3,
-      groupKey: (item) => item.taskRef ? `ticket:${item.taskRef.projectId}:${item.taskRef.ticketId}` : `thread:${item.delivery?.channelId}:${item.delivery?.parentId}`,
+      groupKey: (item) => item.taskRef
+        ? `ticket:${item.taskRef.projectId}:${item.taskRef.ticketId}`
+        : item.delivery?.surface === 'task-comment'
+          ? `ticket:${item.delivery.projectId}:${item.delivery.ticketId}:comments`
+          : `thread:${item.delivery?.channelId}:${item.delivery?.parentId}`,
       run: async (item) => {
-        const key = JSON.stringify([item.taskRef ? `ticket:${item.taskRef.projectId}:${item.taskRef.ticketId}` : `thread:${item.delivery?.channelId}:${item.delivery?.parentId}`, item.kind === 'coord'])
+        const source = item.taskRef
+          ? `ticket:${item.taskRef.projectId}:${item.taskRef.ticketId}`
+          : item.delivery?.surface === 'task-comment'
+            ? `ticket:${item.delivery.projectId}:${item.delivery.ticketId}:comments`
+            : `thread:${item.delivery?.channelId}:${item.delivery?.parentId}`
+        const key = JSON.stringify([source, item.kind === 'coord'])
         const runner = replyRunners.acquire(key, { key, canCoordinate: item.kind === 'coord' })
         activeReplyRunners.add(runner)
         item.control.runner = runner
@@ -760,7 +769,6 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   try { replayState = JSON.parse(readFileSync(replayPath, 'utf8')) } catch { /* first run */ }
   const seenMentions = new Set(Array.isArray(replayState.seenMentions) ? replayState.seenMentions : [])
   const recentMentionSignatures = new Map(Array.isArray(replayState.recentMentionSignatures) ? replayState.recentMentionSignatures : [])
-  const seenActivities = new Set(Array.isArray(replayState.seenActivities) ? replayState.seenActivities : [])
   const deliveredReplies = new Set(Array.isArray(replayState.deliveredReplies) ? replayState.deliveredReplies : [])
   const pendingReplyDeliveries = new Map(Array.isArray(replayState.pendingReplyDeliveries) ? replayState.pendingReplyDeliveries : [])
   const memory = dependencies.memory || createMastraMemory({
@@ -808,7 +816,6 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       writeJson(replayPath, {
         seenMentions: [...seenMentions],
         recentMentionSignatures: [...recentMentionSignatures],
-        seenActivities: [...seenActivities],
         deliveredReplies: [...deliveredReplies],
         pendingReplyDeliveries: [...pendingReplyDeliveries],
         failedTaskVersions: [...failedTaskVersions],
@@ -898,8 +905,6 @@ 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)
@@ -944,15 +949,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
@@ -981,7 +998,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     }).finally(() => { mcpToolDiscoveryPromise = null })
     return mcpToolDiscoveryPromise
   }
-  const callOptionalTicketComment = async ({ projectId, ticketId, content }) => {
+  const callOptionalTicketComment = async ({ projectId, ticketId, content, parentId }) => {
     let names
     try { names = await discoverMcpTools() }
     catch (e) {
@@ -995,7 +1012,13 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     // reached the server, so never try another comment endpoint after an error.
     const name = names.has('create_task_comment') ? 'create_task_comment' : names.has('comment_ticket') ? 'comment_ticket' : ''
     if (!name) return { called: false, reason: 'not-advertised' }
-    const args = { project_id: projectId, ticket_id: ticketId, ...(name === 'create_task_comment' ? { content } : { text: content }) }
+    const args = {
+      project_id: projectId,
+      ticket_id: ticketId,
+      ...(name === 'create_task_comment'
+        ? { content, ...(validBackendId(parentId) ? { parent_id: Number(parentId) } : {}) }
+        : { text: content }),
+    }
     try { return { called: true, tool: name, 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))) {
@@ -1132,7 +1155,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
@@ -1206,6 +1229,34 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     return run
   }
 
+  // Task comments have no channel thread to inspect before delivery. Record the
+  // delivery attempt before the mutation and use the comment id as the one-level
+  // thread root. An ambiguous mutation error is never replayed automatically.
+  const postTaskCommentOnce = async ({ key, projectId, ticketId, parentId, content, sourceKey = '' }) => {
+    if (stopping) throw new Error('Watcher is stopping')
+    const deliveryKey = String(key || '')
+    const message = String(content || '').trim()
+    if (!deliveryKey || !validBackendId(projectId) || !validBackendId(ticketId) || !validBackendId(parentId) || !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)
+    deliveredReplies.add(deliveryKey); trimSeen(deliveredReplies)
+    persistReplay()
+    memory.remember({ key: deliveryKey, kind: 'delivery', state: 'attempted', summary: message, refs: { projectId: Number(projectId), ticketId: Number(ticketId), threadId: Number(parentId) }, meta: { surface: 'task-comment' } })
+    const run = (async () => {
+      const result = await callOptionalTicketComment({ projectId: Number(projectId), ticketId: Number(ticketId), parentId: Number(parentId), content: message })
+      if (!result.called) {
+        throw new Error('No task-comment tool is advertised by the backend')
+      }
+      memory.remember({ key: deliveryKey, kind: 'delivery', state: 'rendered', summary: message, refs: { projectId: Number(projectId), ticketId: Number(ticketId), threadId: Number(parentId) }, meta: { surface: 'task-comment' } })
+      if (sourceKey) memory.connect(deliveryKey, sourceKey, 'responds_to')
+      return { posted: true, result: result.result }
+    })().finally(() => messageDeliveries.delete(deliveryKey))
+    messageDeliveries.set(deliveryKey, run)
+    return run
+  }
+
   async function publishWorkPlan(live, entries, acknowledgement = '') {
     const { control, delivery, taskRef } = live
     const steps = (Array.isArray(entries) ? entries : []).filter(entry => entry && typeof entry.content === 'string' && entry.content.trim()).slice(0, 3).map(entry => entry.content.trim().slice(0, 240))
@@ -1233,7 +1284,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     deliveryProbeBusy = true
     try {
       await mapConcurrent([...pendingReplyDeliveries.values()], 3, async (delivery) => {
-        try { await postMessageOnce(delivery) }
+        try { await (delivery.surface === 'task-comment' ? postTaskCommentOnce(delivery) : postMessageOnce(delivery)) }
         catch (error) { log('reply remains pending: ' + (error?.message || error)) }
       })
     } finally { deliveryProbeBusy = false }
@@ -1426,87 +1477,6 @@ 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 () => {
@@ -1516,7 +1486,6 @@ 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 : []
-      knownProjects = projects.map((project) => ({ id: project.id, name: project.name }))
       await mapConcurrent(projects, 3, async (project) => {
         try {
           const assigned = []
@@ -1568,14 +1537,13 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
           }
         } catch (error) { log('Project reconciliation failed: ' + (error?.message || error)) }
       })
-      await replayRecentActivity(projects)
     } catch (e) {
       log('backlog reconciliation failed: ' + (e && e.message ? e.message : e))
     } finally { backlogProbeBusy = false }
   }
 
   const baseFor = (kind, delivery) => delivery?.watcherOwned
-    ? (kind === 'full' ? fullPrompt + '\n\n' + guardedReplyPrompt : guardedReplyPrompt)
+    ? (kind === 'full' ? fullPrompt + '\n\n' + guardedReplyPrompt : guardedReplyPrompt) + (delivery.surface === 'task-comment' ? '\n\nTASK COMMENT DELIVERY: return the final response for the watcher to post as a reply to the source task comment. Do not call post_message, create_task_comment, or comment_ticket yourself.' : '')
     : kind === 'intro' ? INTRO : kind === 'full' ? fullPrompt : (kind === 'coord' || kind === 'sweep') ? coordinatePrompt : fastPrompt
   // A native final turn ends a cycle. Ticket completion is a separate board
   // action chosen by the agent; tool counts never determine either decision.
@@ -1600,7 +1568,8 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     if (key != null && queues[laneName].has(key)) return queues[laneName].enqueue(null, key)
     const cycleId = `${journal.runId}:cycle:${++cycleSequence}`
     const control = { cycleId, outcome: 'queued', cancelled: false, runner: null, statusTargets: new Set(), enqueuedAt: performance.now() }
-    const cycleData = { cycleId, kind, lane: laneName, model: kind === 'full' ? codeModel : liteModel, workdir: itemWorkdir || (laneName === 'work' ? workdir : ''), ...(taskRef ? { ticket: { projectId: taskRef.projectId, ticketId: taskRef.ticketId } } : {}), ...(delivery ? { thread: { channelId: delivery.channelId, threadId: delivery.parentId } } : {}) }
+    const deliveryTicket = delivery?.surface === 'task-comment' ? { projectId: delivery.projectId, ticketId: delivery.ticketId } : null
+    const cycleData = { cycleId, kind, lane: laneName, model: kind === 'full' ? codeModel : liteModel, workdir: itemWorkdir || (laneName === 'work' ? workdir : ''), ...(taskRef ? { ticket: { projectId: taskRef.projectId, ticketId: taskRef.ticketId } } : deliveryTicket ? { ticket: deliveryTicket } : {}), ...(delivery?.surface !== 'task-comment' && delivery ? { thread: { channelId: delivery.channelId, threadId: delivery.parentId } } : {}) }
     liveCycles.set(cycleId, { data: cycleData, control, taskRef, delivery })
     emit('cycle.queued', { ...cycleData, status: 'queued' })
     return queues[laneName].enqueue({ kind, context, targetChannels, taskRef, delivery, workdir: itemWorkdir, control }, key).then((result) => {
@@ -1658,9 +1627,12 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const activeTaskRef = taskRef
     let verifiedTaskRevision = ''
     const ticketWorktree = preparedWorkdir || (kind === 'full' && activeTaskRef ? findTicketWorktree(workdir, activeTaskRef.ticketId) : '')
+    const guardedTools = delivery?.surface === 'task-comment'
+      ? ['post_message', 'create_task_comment', 'comment_ticket']
+      : delivery?.watcherOwned && !delivery?.allowChannelMessaging ? ['post_message'] : []
     const runnerOptions = {
       cycleId: cycleControl.cycleId, attempt: cycleControl.attempt || 1,
-      ...(delivery?.watcherOwned ? { disabledMcpTools: ['post_message'] } : {}),
+      ...(guardedTools.length ? { disabledMcpTools: guardedTools } : {}),
       ...(ticketWorktree ? { workdir: ticketWorktree } : {}),
     }
     const targets = [...new Set(targetChannels.filter((id) => id != null && Number.isFinite(Number(id))).map(Number))]
@@ -1671,8 +1643,10 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     }
     // credNote + charter live in the cached system prompt now — the per-cycle
     // message is just the event context + the small base instruction.
-    const memoryRefs = delivery
-      ? { channelId: delivery.channelId, threadId: delivery.parentId }
+    const memoryRefs = delivery?.surface === 'task-comment'
+      ? { projectId: delivery.projectId, ticketId: delivery.ticketId, threadId: delivery.parentId }
+      : delivery
+        ? { channelId: delivery.channelId, threadId: delivery.parentId }
       : activeTaskRef ? { projectId: activeTaskRef.projectId, ticketId: activeTaskRef.ticketId } : {}
     let recalled = ''
     try { recalled = await memory.context(memoryRefs) }
@@ -1800,7 +1774,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
           log('guarded reply produced no final text; leaving delivery unrecorded for retry')
         } else {
           const deliveryStartedAt = performance.now()
-          try { await postMessageOnce({ ...delivery, content: reply }) }
+          try { await (delivery.surface === 'task-comment' ? postTaskCommentOnce({ ...delivery, content: reply }) : postMessageOnce({ ...delivery, content: reply })) }
           catch (e) { log('guarded reply delivery failed closed: ' + (e?.message || e)) }
           finally { log(`cycle timing delivery=${Math.round(performance.now() - deliveryStartedAt)}ms kind=${kind}`) }
         }
@@ -1814,9 +1788,9 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   // Distill an event's WS payload into a directive the model can act on without
   // any extra lookup.
   const senderName = (m) => {
-    const s = m && (m.sender || m.user || m.author)
+    const s = m && (m.taskSender || m.task_sender || m.sender || m.user || m.author || m.member || m.taskSenderAgent || m.task_sender_agent || m.senderAgent || m.sender_agent || m.agent)
     if (!s) return ''
-    return (`${s.first_name || ''} ${s.last_name || ''}`.trim() || s.name || s.email || '')
+    return (`${s.first_name || s.firstName || ''} ${s.last_name || s.lastName || ''}`.trim() || s.name || s.display_name || s.identifier || s.email || '')
   }
 
   // Route only concrete repository requests to the coding lane. Conversation
@@ -1922,6 +1896,71 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     }
   }
 
+  const handleTaskComment = async (raw) => {
+    const event = taskCommentFromEvent(raw)
+    const projectId = event?.projectId
+    const ticketId = event?.taskId
+    const comment = event?.comment
+    const commentId = comment && (comment.id ?? comment.comment_id ?? comment.commentId)
+    const text = String(comment?.content ?? comment?.body ?? comment?.text ?? comment?.message ?? '').replace(/\s+/g, ' ').trim()
+    if (!validBackendId(projectId) || !validBackendId(ticketId) || !validBackendId(commentId) || !text) {
+      log('task:comment missing project/task/comment identity or content — ignored')
+      return { status: 'ignored-malformed' }
+    }
+    const sourceKey = `task-comment:${Number(projectId)}:${Number(ticketId)}:${Number(commentId)}`
+    if (memory.has(sourceKey, 'received')) {
+      log(`task:comment duplicate project=${projectId} ticket=${ticketId} comment=${commentId} — skipped`)
+      return { status: 'duplicate' }
+    }
+    try { await ensureSelfAgent() }
+    catch (error) { log('agent identity lookup unavailable; using configured aliases: ' + (error?.message || error)) }
+    if (messageSenderIsSelf(comment, { id: selfAgentId, identifier, slug, name })) return { status: 'ignored-self' }
+    const target = classifyConversationTarget(comment, [...selfAliases], { threadOwned: true })
+    if (target.action !== 'handle') {
+      log('task:comment ignored before model start (' + target.reason + ')')
+      return { status: 'ignored-recipient' }
+    }
+    try {
+      const tools = await discoverMcpTools()
+      if (!tools.has('create_task_comment') && !tools.has('comment_ticket')) {
+        log('task:comment reply tool is not advertised — ignored before model start')
+        return { status: 'ignored-no-delivery-tool' }
+      }
+      const ticketData = toolData(await callMcpTool('get_ticket', { project_id: Number(projectId), ticket_id: Number(ticketId) }), 'get_ticket')
+      const ticket = ticketData.ticket ?? ticketData.task ?? ticketData
+      if (String(ticket.id) !== String(ticketId) || (ticket.project_id != null && String(ticket.project_id) !== String(projectId))) {
+        log('task:comment get_ticket returned mismatched identity — ignored')
+        return { status: 'ignored-mismatch' }
+      }
+      if (!await resolveTaskOwner(ticket)) {
+        log(`task:comment ticket #${ticketId} is not assigned to this agent — ignored`)
+        return { status: 'ignored-unassigned' }
+      }
+      const rootCommentId = messageParentId(comment) ?? Number(commentId)
+      const who = senderName(comment)
+      const peer = messageSenderIsAgent(comment)
+      const ticketSlug = ticketDisplaySlug(ticket)
+      memory.remember({ key: sourceKey, kind: 'task-comment', state: 'received', summary: text, refs: { projectId: Number(projectId), ticketId: Number(ticketId), messageId: Number(commentId), threadId: Number(rootCommentId) } })
+      const delivery = {
+        key: `reply:${sourceKey}`,
+        surface: 'task-comment',
+        projectId: Number(projectId),
+        ticketId: Number(ticketId),
+        parentId: Number(rootCommentId),
+        sourceKey,
+        watcherOwned: true,
+      }
+      const label = ticketSlug || String(ticket.title || 'the assigned ticket')
+      const context = `The watcher received a new comment on your assigned ticket ${JSON.stringify(label)} from ${JSON.stringify(who || (peer ? 'another agent' : 'a teammate'))}: ${JSON.stringify(text)}. Authoritative ticket details: ${JSON.stringify({ slug: ticketSlug, title: ticket.title, description: ticket.description, priority: ticket.priority, status: ticket.type?.name ?? ticket.task_type?.name ?? ticket.status ?? ticket.state })}. Answer the comment directly in the context of this ticket. Do not call post_message or any task-comment tool; return only the final reply and the watcher will post it once in the source comment thread.${peer ? ' This was authored by another team agent. Address its concrete question or request without replacing it with ticket inventory or adding an open-ended reciprocal question.' : ''}`
+      log(`task:comment project=${projectId} ticket=${ticketId} comment=${commentId} -> coordination lane`)
+      void drain('coord', context, [], null, delivery)
+      return { status: 'queued' }
+    } catch (error) {
+      log(`task:comment verification failed for ticket #${ticketId}: ` + (error?.message || error))
+      return { status: 'retry' }
+    }
+  }
+
   const conversationEventData = (value) => {
     const outer = value && typeof value === 'object' && !Array.isArray(value) ? value : {}
     const data = outer.data && typeof outer.data === 'object' && !Array.isArray(outer.data) ? outer.data : {}
@@ -1938,6 +1977,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   const mentionIntake = new Map()
   function onEvent(k, d) {
     if (stopping) return
+    if (k === 'task:comment') return trackOperation(handleTaskComment(d))
     const conversationEvent = k === 'agent:mention' || k === 'agent:message' || k === 'channel:message'
     if (!conversationEvent) return trackOperation(routeEvent(k, d))
     const eventData = conversationEventData(d)
@@ -2002,13 +2042,16 @@ 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 === 'task:comment') {
+      return handleTaskComment(raw)
     } else if (k === 'agent:mention') {
       const cid = raw.channel_id != null ? raw.channel_id : (raw.channelId != null ? raw.channelId : null)
       const msg = raw.message && typeof raw.message === 'object' ? raw.message : {}
       const text = String(msg.content || msg.body || msg.text || '').replace(/\s+/g, ' ')
       const who = senderName(msg)
+      const peerMessage = messageSenderIsAgent(msg)
       // Reply IN THE SAME THREAD: parent is the thread root (the message's own id
       // for a top-level mention, or its parent when the mention is itself a reply).
       const mid = msg.message_id ?? msg.messageId ?? msg.id ?? null
@@ -2055,8 +2098,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 +2129,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,20 +2165,21 @@ 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.'
+      if (ctx && peerMessage) ctx += ' This request was authored by another team agent. Treat its concrete question or request as real team coordination. Answer the substance directly. Do not replace it with your own ticket inventory, and do not append a reciprocal question or open-ended invitation unless the source explicitly asks for one.'
       if (ctx && raw._threadRootContent) ctx += ` Verified thread root authored by you (context, not a new request): ${JSON.stringify(raw._threadRootContent)}. For requested repairs, inspect the referenced PR and its branch, run the failing verification, and fix that existing work. A review/testing handoff does not prevent an explicit human repair request.`
       if (codingMention) {
         // 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(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))
@@ -2144,7 +2189,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   }
 
   // The WebSocket drives real-time reactions (task:created/updated assigned to us,
-  // agent:mention, agent:message, and channel:message). Verified organization subscriptions
+  // task:comment, agent:mention, agent:message, and channel:message). Verified organization subscriptions
   // recover channel mentions even when the backend omits targeted dispatch.
   // All conversation event types share recipient, ownership and deduplication guards.
   log('up — backend WS watcher on ' + wsUrl + (canCode ? ' [code: ' + workdir + ']' : ''))
@@ -2159,6 +2204,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 })
 
@@ -2209,10 +2255,6 @@ 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
@@ -2252,7 +2294,6 @@ 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 */ }
@@ -2277,7 +2318,6 @@ 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 },
   }