openvisio-agent 0.19.11 → 0.19.12

package/package.json

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

package/scripts/certify.mjs

@@ -63,8 +63,9 @@ const assertions = [
   ['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'")],
   ['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 =')],
+  ['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')")],
+  ['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 legacy roots are verified before routing', watcher.includes('saveOwnThread(channelId, postedId, message)') && watcher.includes('await resolveOwnThread(cid, parent)') && 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'")],
   ['thread cancellation is rechecked immediately before watcher delivery', watcher.includes('const newlyCancelled = suppressCancelled()') && watcher.includes('if (newlyCancelled) return newlyCancelled')],
   ['generic coding pickup messages are absent', !watcher.includes("I've picked this up and will return here with the verified result")],

package/src/events.mjs

@@ -400,7 +400,7 @@ export function renderedAgentMessages(value, identity = {}) {
         }
       }
     }
-    for (const key of ['messages', 'replies', 'items', 'data', 'result', 'thread', 'message']) {
+    for (const key of ['messages', 'replies', 'items', 'data', 'result', 'thread', 'message', 'root']) {
       if (row[key] && typeof row[key] === 'object') visit(row[key], depth + 1)
     }
   }
@@ -487,12 +487,13 @@ export function classifyConversationTarget(message, selfAliases, { threadOwned =
 // Require an actionable repository verb and a concrete code/repository object.
 // Broad nouns such as "feature", "API", "file", or "documentation" on their
 // own describe plenty of product conversations and must not start a coding lane.
-export function conversationNeedsCode(value) {
+export function conversationNeedsCode(value, { rootContent = '' } = {}) {
   const text = String(value || '')
   if (/\b(?:do\s+not|don't|dont|stop|cancel|stand\s+down)\b/i.test(text)) return false
-  const action = /\b(?:implement|fix|debug|refactor|change|update|add|remove|write|edit|test|build|deploy|release|migrate|wire|integrate)\b/i.test(text)
+  const action = /\b(?:implement|fix|debug|repair|rebuild|rerun|refactor|change|update|add|remove|write|edit|test|build|deploy|release|migrate|wire|integrate)\b/i.test(text)
   const target = /\b(?:code|codebase|repository|repo|github|branch|commit|pull\s+request|pr|endpoint|route|component|page|screen|ui|function|class|database|migration|schema|package|typescript|javascript|python|swift|rust|golang|css|html|source\s+file|tests?)\b/i.test(text)
-  return action && target
+  const contextualRepair = /\b(?:fix|debug|repair|rebuild|rerun|run\s+(?:the\s+)?(?:build|tests?))\b/i.test(text) && /\b(?:github\.com\/\S+\/pull\/\d+|pull\s+request|repository|repo|branch|commit)\b/i.test(rootContent)
+  return (action && target) || contextualRepair
 }
 
 export function conversationAsksPendingTickets(value) {

package/src/memory.mjs

@@ -155,5 +155,5 @@ export function createMastraMemory({ ledgerPath, databasePath, resourceId, maxNo
   }
 
   const settled = async () => { await Promise.all(pending.values()); await memory.settled() }
-  return { remember, connect: ledger.connect, recall: ledger.recall, context, has: ledger.has, persist: ledger.persist, settled, provider: 'mastra-libsql' }
+  return { remember, connect: ledger.connect, recall: ledger.recall, context, has: ledger.has, get: ledger.get, persist: ledger.persist, settled, provider: 'mastra-libsql' }
 }

package/src/thread-context.mjs

@@ -0,0 +1,27 @@
+import { renderedAgentMessages } from './events.mjs'
+
+// An agent's own root post establishes a conversation, even if nobody tagged
+// the agent before replying. Verify the exact root, never mere participation.
+export function ownThreadRoot(thread, rootId, identity) {
+  return renderedAgentMessages(thread, identity).find((row) => String(row.id) === String(rootId)) || null
+}
+
+export function createThreadContextResolver({ read, save, cancelled, load, identity }) {
+  const pending = new Map()
+  return async (channelId, rootId) => {
+    if (channelId == null || rootId == null || cancelled(channelId, rootId)) return ''
+    const cached = read(channelId, rootId)
+    if (cached) return cached
+    const key = `${channelId}:${rootId}`
+    if (!pending.has(key)) {
+      const request = Promise.resolve().then(() => load(channelId, rootId)).then((thread) => {
+        const root = ownThreadRoot(thread, rootId, identity())
+        if (!root || cancelled(channelId, rootId)) return ''
+        save(channelId, rootId, root.content)
+        return root.content
+      }).finally(() => pending.delete(key))
+      pending.set(key, request)
+    }
+    return pending.get(key)
+  }
+}

package/src/watch.mjs

@@ -20,6 +20,7 @@ import { mapConcurrent } from './concurrency.mjs'
 import { releaseAuthorizedPause } from './authorization-resume.mjs'
 import { dedicatedChannel, repliesAfterSource } from './channel-routing.mjs'
 import { createTaskTypeLookup } from './task-types.mjs'
+import { createThreadContextResolver } from './thread-context.mjs'
 import { assignmentRequest, assignmentStatusOnly, routeAssignments } from './assignment-routing.mjs'
 import { modelProcessOptions, stopModelProcess } from './process-lifecycle.mjs'
 import { createMastraAcpRunner } from './mastra-harness.mjs'
@@ -876,6 +877,25 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const controlKey = threadControlKey(channelId, parentId)
     if (controlKey) memory.remember({ key: controlKey, kind: 'thread', state: 'active', summary, refs: { channelId: Number(channelId), threadId: parentId } })
   }
+  const saveOwnThread = (channelId, rootId, content) => {
+    memory.remember({ key: `own-root:${channelId}:${rootId}`, kind: 'thread', state: 'authored', summary: content, refs: { channelId: Number(channelId), threadId: rootId }, meta: { rootContent: content } })
+    if (!memory.has(threadControlKey(channelId, rootId), 'cancelled')) activateThread(channelId, rootId, content)
+  }
+  const resolveOwnThread = createThreadContextResolver({
+    read: (cid, root) => {
+      const cached = memory.get(`own-root:${cid}:${root}`)?.meta?.rootContent
+      if (cached) return cached
+      // Previous releases recorded the posted message id but not ownership.
+      // This also recovers roots when the thread API returns only replies.
+      const previous = memory.recall({ channelId: cid }, 1000).find((node) => node.kind === 'delivery' && node.state === 'rendered' && node.refs?.threadId == null && String(node.meta?.messageId) === String(root))
+      if (previous?.summary) saveOwnThread(cid, root, previous.summary)
+      return previous?.summary || ''
+    },
+    save: saveOwnThread,
+    cancelled: (cid, root) => memory.has(threadControlKey(cid, root), 'cancelled'),
+    identity: () => ({ id: selfAgentId, identifier, slug, name: slug }),
+    load: async (cid, root) => toolData(await callMcpTool('list_message_thread', { channel_id: Number(cid), message_id: Number(root) })),
+  })
   const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', sourceMessageId, allowCancelled = false }) => {
     const deliveryKey = String(key || '')
     if (parentId == null) {
@@ -923,6 +943,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         ...(parentId != null ? { parent_id: Number(parentId) } : {}),
         content: message,
       }))
+      const postedId = result.id ?? result.message?.id ?? result.message_id
+      if (parentId == null && postedId != null) saveOwnThread(channelId, postedId, message)
       deliveredReplies.add(deliveryKey); trimSeen(deliveredReplies); persistReplay()
       memory.remember({ key: deliveryKey, kind: 'delivery', state: 'rendered', summary: message, refs: { channelId: Number(channelId), ...(parentId != null ? { threadId: Number(parentId) } : {}), ...(Number.isFinite(Number(projectId)) ? { projectId: Number(projectId) } : {}) }, meta: { messageId: result.id ?? result.message?.id ?? null } })
       if (sourceKey) memory.connect(deliveryKey, sourceKey, 'responds_to')
@@ -1193,7 +1215,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
             // 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
+            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.
@@ -1203,7 +1225,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
               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
+                if (memory.has(activitySourceKey, 'received')) continue
               }
               mentionActivity.push({
                 projectId: project.id,
@@ -1519,7 +1541,27 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     }
   }
 
+  const mentionIntake = new Map()
   function onEvent(k, d) {
+    if (k !== 'agent:mention') return routeEvent(k, d)
+    const cid = d?.channel_id ?? d?.channelId
+    const message = d?.message || {}
+    const parent = message.parent_id ?? message.parentId
+    const key = `${cid}:${parent ?? message.id ?? message.message_id}`
+    // Keep redirects ordered while a legacy root is being verified. Other
+    // conversations can resolve and run independently.
+    const next = (mentionIntake.get(key) || Promise.resolve()).then(async () => {
+      const preliminary = classifyConversationTarget(message, [...selfAliases])
+      const irrelevant = preliminary.action === 'ignore' && preliminary.reason !== 'unaddressed-thread-activity'
+      const rootContent = parent == null || irrelevant || preliminary.action === 'stand_down' ? '' : await resolveOwnThread(cid, parent)
+      routeEvent(k, { ...d, _threadRootContent: rootContent })
+    }).catch((error) => log('mention thread verification failed: ' + (error?.message || error)))
+      .finally(() => { if (mentionIntake.get(key) === next) mentionIntake.delete(key) })
+    mentionIntake.set(key, next)
+    return next
+  }
+
+  function routeEvent(k, d) {
     const raw = d && typeof d === 'object' ? d : {}
     if (k === 'task:assigned' || k === 'task:updated') {
       void handleTaskSignal(k, raw)
@@ -1629,13 +1671,14 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       // Light up the live status the instant we pick this up; drain owns the
       // subsequent working/typing heartbeat for its lane.
       if (cid != null) sendStatus(cid, 'thinking')
-      const codingMention = canCode && conversationNeedsCode(text)
+      const codingMention = canCode && conversationNeedsCode(text, { rootContent: raw._threadRootContent })
       const replyDelivery = conversationDelivery(codingMention ? 'result' : 'reply', !codingMention)
-      const ctx = cid != null
+      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}".` : ''} The complete message is already here; do not call get_resource, get_marching_orders, poll_inbox, list_mcp_resources, or list_mcp_resource_templates.`
           : `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)` : ''}, plus agent_identifier + agent_api_key from the AUTH line above. 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.` : ''} The complete message is already here. Do not call get_resource, get_marching_orders, poll_inbox, list_mcp_resources, or list_mcp_resource_templates.${codingMention ? ' Stop only after the work and final result/blocker.' : ' After your single reply, STOP.'}`
         : undefined
+      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