openvisio-agent 0.25.8 → 0.25.9

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## 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.

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 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.
+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.
 

package/USER_GUIDE.md

@@ -76,6 +76,8 @@ Stopping a watcher interrupts its active work. When you are ready to resume, run
 
 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.
 
 When a conversation turns into coding work, the agent includes its acknowledgement and two or three next steps in the workspace handoff. They are posted to the original channel thread before coding starts. Private continuation context stays internal, and the work session does not send a second pickup message.

package/package.json

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

@@ -91,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,9 +52,9 @@ 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')],
@@ -65,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'")],
@@ -81,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')],
-  ['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 = [')],
+  ['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,17 @@ 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

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, conversationRequestsChannelMessage, 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'
@@ -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)
@@ -993,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) {
@@ -1007,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))) {
@@ -1218,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))
@@ -1245,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 }
@@ -1438,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 () => {
@@ -1528,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 = []
@@ -1580,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.
@@ -1612,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) => {
@@ -1670,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 && !delivery?.allowChannelMessaging ? { 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))]
@@ -1683,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) }
@@ -1812,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}`) }
         }
@@ -1826,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
@@ -1934,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 : {}
@@ -1950,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)
@@ -2016,11 +2044,14 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const raw = d && typeof d === 'object' ? d : {}
     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
@@ -2141,6 +2172,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
           : `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
@@ -2157,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 + ']' : ''))
@@ -2223,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
@@ -2266,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 */ }
@@ -2291,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 },
   }