openvisio-agent 0.19.1 → 0.19.3

package/README.md

@@ -66,7 +66,7 @@ The backend MCP may be stateful or stateless. A successful initialize response w
 
 Codex BYO agents follow the repository's normative runtime specification in `docs/CODEX_BYO_AGENT_SPEC.md`: one WebSocket identity, independent Sol reply/work lanes, authoritative `get_ticket` verification for assignments, REST-backed in-app activity, persistent replay suppression, and runtime evidence gates before completion. Maintainers must run `npm run certify` before publishing.
 
-An `agent:mention` event only wakes the watcher; it does not grant ownership of the conversation. The actual source message is checked before any model starts. Messages redirected to another agent and unaddressed agent chatter stay silent, while a direct stand-down cancels queued/running work for that thread. The watcher does not broadcast working, thinking, or typing presence updates. Claude and OpenCode may add one concrete progress update after work begins, but must continue and post a distinct verified result or blocker afterward; Codex keeps cancellation-safe delivery watcher-owned and renders the verified final answer once.
+An `agent:mention` event only wakes the watcher; the actual source message is checked before any model starts. 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. The watcher does not broadcast working, thinking, or typing presence updates. Claude and OpenCode may add one concrete progress update after work begins, but must continue and post a distinct verified result or blocker afterward; Codex keeps cancellation-safe delivery watcher-owned and renders the verified final answer once.
 
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openvisio-agent",
-  "version": "0.19.1",
+  "version": "0.19.3",
   "description": "Connect Claude Code, Codex, or OpenCode to an OpenVisio team — MCP tools + optional autonomy — in one command.",
   "type": "module",
   "bin": {

package/scripts/certify.mjs

@@ -56,7 +56,9 @@ const assertions = [
   ['single-watcher acquisition is atomic and fails closed', watcher.includes("openSync(lockPath, 'wx')") && watcher.includes('Could not acquire the single-watcher lock')],
   ['websocket and activity mention delivery share a replay guard', watcher.includes('markMentionHandled(activityMessage, activityChannelId)') && watcher.includes('markMentionHandled(msg, cid)') && watcher.includes('recentMentionSignatures')],
   ['reconciled mentions reuse the guarded websocket delivery path', watcher.includes("onEvent('agent:mention'") && watcher.includes('_mentionAlreadyMarked: true')],
-  ['conversation wake events are recipient-filtered before model start', watcher.includes('classifyConversationTarget(msg, [...selfAliases])') && events.includes("reason: 'explicit-other-recipient'") && events.includes("reason: 'other-agent-chatter'")],
+  ['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'")],
+  ['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("!ownedActivity || memory.has(activitySourceKey, 'received')")],
   ['coding mentions require an action and concrete repository target', watcher.includes('conversationNeedsCode(text)') && events.includes('const action =') && events.includes('const target =')],
   ['stand-down and redirects cancel 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'")],
   ['thread cancellation is rechecked immediately before watcher delivery', watcher.includes('const newlyCancelled = suppressCancelled()') && watcher.includes('if (newlyCancelled) return newlyCancelled')],

package/src/events.mjs

@@ -450,7 +450,7 @@ export function messageSenderIsAgent(message) {
 // `agent:mention`, even when the new message names somebody else. Treat the event
 // name as a wake-up hint only: recipient ownership is decided from the actual
 // message before a model or work lane is allowed to run.
-export function classifyConversationTarget(message, selfAliases) {
+export function classifyConversationTarget(message, selfAliases, { threadOwned = false } = {}) {
   const m = message && typeof message === 'object' ? message : {}
   const text = String(m.content ?? m.body ?? m.text ?? m.message ?? '').replace(/\s+/g, ' ').trim()
   const { self: selfMentions, other: otherMentions, all: mentions } = conversationMentions(text, selfAliases)
@@ -471,11 +471,14 @@ export function classifyConversationTarget(message, selfAliases) {
   if (explicitSelf && requestTargetsLaterAgent(text, selfAliases)) {
     return { action: 'ignore', reason: 'redirected-to-later-agent', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
   }
-  // A transport-level `agent:mention` can be emitted for every new message in a
-  // thread whose root once mentioned this agent. With no mention or explicit
-  // stand-down in the current message, ownership is ambiguous. Fail closed
-  // instead of making every agent that ever joined the thread answer it.
+  // An explicit mention establishes durable thread ownership in the watcher.
+  // Later human follow-ups in that same active thread remain addressed to this
+  // agent without requiring another @mention. Redirects, stand-downs and agent
+  // 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: 'ignore', reason: 'unaddressed-thread-activity', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
   }
   return { action: 'handle', reason: 'explicit-self-recipient', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }

package/src/watch.mjs

@@ -1361,15 +1361,28 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
             ? item.message
             : data?.message && typeof data.message === 'object' ? data.message : item
           const activityText = String(activityMessage?.content ?? activityMessage?.body ?? activityMessage?.text ?? '').toLowerCase()
-          // Reconciliation recovers explicit mentions only. Searching the whole
-          // activity envelope can match an old thread root and replay a new reply
-          // that is actually addressed to another agent.
-          if (!seenActivities.has(activityKey) && mentionNeedles.some((needle) => activityText.includes(needle)) && /message|mention|channel/i.test(text)) {
-            const activityChannelId = item?.channel_id ?? item?.channelId ?? data?.channel_id ?? data?.channelId
+          const activityChannelId = item?.channel_id ?? item?.channelId ?? data?.channel_id ?? data?.channelId
+          const activityMessageId = activityMessage?.id ?? activityMessage?.message_id ?? activityMessage?.messageId
+          const activityParentId = activityMessage?.parent_id ?? activityMessage?.parentId
+          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
+          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.
-            if (markMentionHandled(activityMessage, activityChannelId)) continue
+            // 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 (!ownedActivity || memory.has(activitySourceKey, 'received')) continue
+            }
             mentionActivity.push({
               projectId: project.id,
               project: project.name,
@@ -1709,11 +1722,21 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const mid = msg.id != null ? msg.id : (msg.message_id != null ? msg.message_id : null)
       const parent = msg.parent_id != null ? msg.parent_id : (msg.parentId != null ? msg.parentId : null)
       const threadRoot = parent != null ? parent : mid
+      const controlKey = threadControlKey(cid, threadRoot)
+      const threadOwned = !!controlKey && memory.has(controlKey, 'active')
+      const mentionKeys = mentionDedupeKeys(msg, cid)
+      const sourceKey = `mention:${cid ?? '?'}:${mentionKeys.idKey || mentionKeys.signatureKey || threadRoot || Date.now()}`
       // De-dupe: the same mention re-delivered (reconnect replay / dup fan-out) must
       // NOT trigger a second reply. Key by message id, or a channel+text signature
-      // when the payload carries no id.
-      if (!raw._mentionAlreadyMarked && markMentionHandled(msg, cid)) { log('agent:mention (dup) — skipped'); return }
-      const target = classifyConversationTarget(msg, [...selfAliases])
+      // when the payload carries no id. Older recipient filtering acknowledged
+      // some owned-thread follow-ups before routing them. If such a message is
+      // replayed, its replay key exists but its received ledger entry does not;
+      // admit it once so the corrected ownership rule can recover the message.
+      if (!raw._mentionAlreadyMarked && markMentionHandled(msg, cid)) {
+        if (!threadOwned || memory.has(sourceKey, 'received')) { log('agent:mention (dup) — skipped'); return }
+        log('agent:mention replay recovered for active owned thread')
+      }
+      const target = classifyConversationTarget(msg, [...selfAliases], { threadOwned })
       if (target.action === 'ignore') {
         log('agent:mention ignored before model start (' + target.reason + ')')
         // A redirect or another agent taking over invalidates any older work or
@@ -1724,8 +1747,6 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         }
         return
       }
-      const mentionKeys = mentionDedupeKeys(msg, cid)
-      const sourceKey = `mention:${cid ?? '?'}:${mentionKeys.idKey || mentionKeys.signatureKey || threadRoot || Date.now()}`
       if (target.action === 'stand_down') {
         if (cid != null && threadRoot != null) {
           cancelThread(cid, threadRoot, text || 'Explicit stand-down')