openvisio-agent 0.19.12 → 0.20.0

package/src/channel-routing.mjs

@@ -1,26 +1,33 @@
 const normalize = (name) => String(name || '').toLowerCase().replace(/^#/, '').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '')
-const validId = (id) => id != null && Number.isSafeInteger(Number(id)) && Number(id) > 0
+const validId = (id) => (typeof id === 'number' || (typeof id === 'string' && /^\d+$/.test(id))) && Number.isSafeInteger(Number(id)) && Number(id) > 0
 
 export function repliesAfterSource(messages, sourceMessageId) {
-  if (sourceMessageId == null) return messages
+  const rows = Array.isArray(messages) ? messages : []
+  if (sourceMessageId == null) return rows
   // Backend message ids are monotonically increasing database ids. For opaque
   // ids, rely on the persisted source delivery key rather than suppressing a
   // new question because the agent replied to an earlier one in this thread.
   if (!/^\d+$/.test(String(sourceMessageId))) return []
-  return messages.filter((message) => /^\d+$/.test(String(message.id)) && BigInt(message.id) > BigInt(sourceMessageId))
+  return rows.filter((message) => message && /^\d+$/.test(String(message.id)) && BigInt(message.id) > BigInt(sourceMessageId))
 }
 
 export function dedicatedChannel(channels, { id, identifier, aliases = [], channelId } = {}) {
-  const usable = channels.filter((channel) => validId(channel?.id))
+  const usable = (Array.isArray(channels) ? channels : []).filter((channel) => validId(channel?.id))
+  if (channelId != null && !validId(channelId)) return null
   if (validId(channelId)) return usable.find((channel) => Number(channel.id) === Number(channelId)) || null
-  const owned = usable.filter((channel) =>
-    (id != null && channel.agent_id != null && String(channel.agent_id) === String(id)) ||
-    (identifier && channel.agent_identifier === identifier))
+  const ownerId = (channel) => channel.agent_id ?? channel.agentId
+  const ownerIdentifier = (channel) => channel.agent_identifier ?? channel.agentIdentifier
+  const owned = usable.filter((channel) => {
+    if (id != null && ownerId(channel) != null) return String(ownerId(channel)) === String(id)
+    return identifier && ownerIdentifier(channel) === identifier
+  })
   if (owned.length) return owned.length === 1 ? owned[0] : null
   const names = new Set([identifier, ...aliases].filter(Boolean).flatMap((alias) => {
     const name = normalize(alias)
     return [name, `agent-${name}`, `${name}-agent`]
   }).filter((name) => !['general', 'team', 'project', 'dev', 'development'].includes(name)))
-  const matches = usable.filter((channel) => names.has(normalize(channel.name)))
+  // Explicit ownership always outranks a similar name. A recycled agent name
+  // must never route a new thread into somebody else's dedicated channel.
+  const matches = usable.filter((channel) => ownerId(channel) == null && !ownerIdentifier(channel) && names.has(normalize(channel.name)))
   return matches.length === 1 ? matches[0] : null
 }

package/src/codex-mcp-proxy.mjs

@@ -5,35 +5,80 @@ import { createMcpHttpClient } from './mcp-http.mjs'
 
 export function toolWithoutCredentialInputs(tool) {
   const copy = structuredClone(tool)
-  const schema = copy.inputSchema ?? copy.input_schema
-  if (!schema || typeof schema !== 'object') return copy
-  if (schema.properties && typeof schema.properties === 'object') {
-    delete schema.properties.agent_api_key
-    delete schema.properties.agent_identifier
-  }
-  if (Array.isArray(schema.required)) {
-    schema.required = schema.required.filter((name) => name !== 'agent_api_key' && name !== 'agent_identifier')
+  for (const schema of [copy.inputSchema, copy.input_schema]) {
+    if (!schema || typeof schema !== 'object') continue
+    if (schema.properties && typeof schema.properties === 'object') {
+      delete schema.properties.agent_api_key
+      delete schema.properties.agent_identifier
+    }
+    if (Array.isArray(schema.required)) {
+      schema.required = schema.required.filter((name) => name !== 'agent_api_key' && name !== 'agent_identifier')
+    }
   }
   return copy
 }
 
 export function toolAllowed(name, { disabled = new Set(), allowed = null } = {}) {
   const tool = String(name || '')
-  return !disabled.has(tool) && (!(allowed instanceof Set) || allowed.has(tool))
+  return !!tool && !disabled.has(tool) && (!(allowed instanceof Set) || allowed.has(tool))
+}
+
+export function agentResultWithoutCredentials(result) {
+  const credentials = new Set()
+  const credentialFields = new Set(['apikey', 'agentapikey', 'password', 'passwordhash', 'accesstoken', 'refreshtoken', 'clientsecret', 'secret', 'token'])
+  const strip = (value) => {
+    if (Array.isArray(value)) return value.map(strip)
+    if (!value || typeof value !== 'object') return value
+    return Object.fromEntries(Object.entries(value).flatMap(([key, item]) => {
+      if (credentialFields.has(key.replace(/[_-]/g, '').toLowerCase())) {
+        if (typeof item === 'string' && item) credentials.add(item)
+        return []
+      }
+      return [[key, strip(item)]]
+    }))
+  }
+  const copy = strip(result)
+  const parsedText = new Map()
+  for (const item of Array.isArray(copy?.content) ? copy.content : []) {
+    if (item?.type !== 'text' || typeof item.text !== 'string' || !/^\s*[\[{]/.test(item.text)) continue
+    let data
+    try { data = JSON.parse(item.text) }
+    catch { throw new Error('MCP agent directory returned malformed JSON') }
+    parsedText.set(item, strip(data))
+  }
+  // The backend can include the same records in structuredContent and in a
+  // rendered markdown summary. Gather secrets first, then redact every rendering.
+  const redact = (value) => {
+    if (typeof value === 'string') {
+      for (const secret of credentials) value = value.split(secret).join('[redacted]')
+      return value
+    }
+    if (Array.isArray(value)) return value.map(redact)
+    if (!value || typeof value !== 'object') return value
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redact(item)]))
+  }
+  for (const [item, data] of parsedText) item.text = JSON.stringify(redact(data))
+  return redact(copy)
+}
+
+export function proxyToolPolicyFromEnvironment(env = process.env) {
+  const parse = (key, fallback) => {
+    let value
+    try { value = JSON.parse(env[key] ?? fallback) }
+    catch { throw new Error(`Invalid MCP tool policy: ${key}`) }
+    if (value !== null && (!Array.isArray(value) || value.some((name) => typeof name !== 'string' || !name))) throw new Error(`Invalid MCP tool policy: ${key}`)
+    return value
+  }
+  const disabled = parse('OPENVISIO_CODEX_DISABLED_TOOLS', '[]')
+  const allowed = parse('OPENVISIO_CODEX_ALLOWED_TOOLS', 'null')
+  return { disabled: new Set(disabled || []), allowed: allowed === null ? null : new Set(allowed) }
 }
 
 export function runCodexMcpProxy() {
   const url = process.env.OPENVISIO_CODEX_MCP_URL
   const apiKey = process.env.OPENVISIO_CODEX_API_KEY
   const identifier = process.env.OPENVISIO_CODEX_IDENTIFIER
-  let disabledTools = []
-  try { disabledTools = JSON.parse(process.env.OPENVISIO_CODEX_DISABLED_TOOLS || '[]') } catch { /* no disabled tools */ }
-  const disabled = new Set(Array.isArray(disabledTools) ? disabledTools.map(String) : [])
-  let allowedTools = null
-  try {
-    const parsed = JSON.parse(process.env.OPENVISIO_CODEX_ALLOWED_TOOLS || 'null')
-    if (Array.isArray(parsed)) allowedTools = new Set(parsed.map(String))
-  } catch { /* unrestricted except for disabled tools */ }
+  const { disabled, allowed: allowedTools } = proxyToolPolicyFromEnvironment()
   if (!url || !apiKey || !identifier) throw new Error('OpenVisio Codex MCP bridge is missing its watcher environment.')
   const client = createMcpHttpClient({ url, apiKey, identifier, clientVersion: 'openvisio-agent-codex-proxy' })
   const reply = (id, result) => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n')
@@ -77,7 +122,7 @@ export function runCodexMcpProxy() {
           if (!(allowedTools instanceof Set) || !allowedTools.has(name) || !/^(?:list_|get_|codebase_tree$)/.test(name)) throw error
           result = await client.callTool(name, request.params?.arguments || {})
         }
-        reply(id, result)
+        reply(id, /^(?:list_agents|get_agent|get_agent_details)$/.test(name) ? agentResultWithoutCredentials(result) : result)
       } else if (id != null) {
         process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } }) + '\n')
       }

package/src/concurrency.mjs

@@ -1,12 +1,14 @@
 export async function mapConcurrent(items, concurrency, run) {
   if (!Number.isInteger(concurrency) || concurrency < 1) throw new Error('Invalid concurrency')
   const results = new Array(items.length)
-  let next = 0
+  let next = 0, failed = false, failure
   await Promise.all(Array.from({ length: Math.min(items.length, concurrency) }, async () => {
-    while (next < items.length) {
+    while (!failed && next < items.length) {
       const index = next++
-      results[index] = await run(items[index], index)
+      try { results[index] = await run(items[index], index) }
+      catch (error) { if (!failed) failure = error; failed = true }
     }
   }))
+  if (failed) throw failure
   return results
 }

package/src/cycle-queue.mjs

@@ -8,6 +8,9 @@ export function createCycleQueue({ run, onError = () => {}, concurrency = 1, gro
   const active = new Map()
   const activeGroups = new Set()
   let sequence = 0
+  const report = (error, item) => {
+    try { Promise.resolve(onError(error, item)).catch(() => {}) } catch { /* logging cannot strand the queue */ }
+  }
 
   const pump = () => {
     while (active.size < concurrency && pending.size) {
@@ -24,7 +27,7 @@ export function createCycleQueue({ run, onError = () => {}, concurrency = 1, gro
       void (async () => {
         try { entry.resolve(await run(entry.item)) }
         catch (error) {
-          try { onError(error, entry.item) } catch { /* logging cannot strand the queue */ }
+          report(error, entry.item)
           entry.resolve({ status: 'failed' })
         } finally {
           active.delete(key)
@@ -41,7 +44,8 @@ export function createCycleQueue({ run, onError = () => {}, concurrency = 1, gro
       if (pending.has(key)) return pending.get(key).promise
       let resolve
       const promise = new Promise((done) => { resolve = done })
-      const group = String(groupKey(item) || '')
+      const rawGroup = groupKey(item)
+      const group = rawGroup == null ? '' : String(rawGroup)
       pending.set(key, { item, promise, resolve, group })
       pump()
       return promise
@@ -52,7 +56,16 @@ export function createCycleQueue({ run, onError = () => {}, concurrency = 1, gro
         pending.delete(key)
         entry.resolve({ status: 'canceled' })
       }
-      for (const entry of active.values()) if (predicate(entry.item)) cancelActive(entry.item)
+      for (const entry of active.values()) {
+        if (!predicate(entry.item)) continue
+        try { Promise.resolve(cancelActive(entry.item)).catch((error) => report(error, entry.item)) }
+        catch (error) { report(error, entry.item) }
+      }
+    },
+    async settled() {
+      // Capture work already accepted. Shutdown first stops intake and cancels
+      // pending entries, then waits for active workers to finish their cleanup.
+      await Promise.all([...active.values(), ...pending.values()].map((entry) => entry.promise))
     },
     has(key) { return active.has(key) || pending.has(key) },
     get size() { return pending.size + active.size },

package/src/events.mjs

@@ -23,7 +23,15 @@ export function taskFromEvent(payload) {
 
 export function taskAgentId(task) {
   if (!task || typeof task !== 'object') return null
-  return task.agent_id != null ? task.agent_id : (task.agentId != null ? task.agentId : null)
+  return task.agent_id ?? task.agentId ?? task.agent?.id ?? task.assigned_agent?.id ?? task.assignedAgent?.id ?? null
+}
+
+export function taskBelongsToAgent(task, { id, identifier } = {}) {
+  if (!task || typeof task !== 'object') return false
+  const assignedId = taskAgentId(task)
+  if (assignedId != null && id != null) return String(assignedId) === String(id)
+  const assignedIdentifier = task.agent_identifier ?? task.agentIdentifier ?? task.agent?.identifier ?? task.agent?.slug ?? task.assigned_agent?.identifier ?? task.assigned_agent?.slug ?? task.assignedAgent?.identifier ?? task.assignedAgent?.slug
+  return !!identifier && assignedIdentifier != null && String(assignedIdentifier) === String(identifier)
 }
 
 // Backend task ids are database plumbing. Teammates identify tickets by the
@@ -87,9 +95,9 @@ export function agentAddedByName(agent) {
   return personDisplayName(addedBy)
 }
 
-export function buildTaskCompletionReport(task, { projectId, fallbackText = '', recipientName = '' } = {}) {
+export function buildTaskCompletionReport(task, { projectId, fallbackText = '', recipientName = '', completedTypeIds = new Set(), reviewTypeIds = new Set() } = {}) {
   if (!task || typeof task !== 'object' || task.id == null) return null
-  if (!taskIsCompleted(task) && !taskIsAwaitingReview(task)) return null
+  if (!taskIsCompleted(task, completedTypeIds) && !taskIsAwaitingReview(task, reviewTypeIds)) return null
 
   const evidence = [task.description, fallbackText].filter(Boolean).join('\n')
   const prUrl = /https:\/\/github\.com\/[^\s)\]}>]+\/pull\/\d+/i.exec(evidence)?.[0]?.replace(/[.,;:]+$/, '') || ''
@@ -97,7 +105,7 @@ export function buildTaskCompletionReport(task, { projectId, fallbackText = '',
 
   const requester = String(recipientName || '').trim()
   const title = String(task.title || 'Untitled task').replace(/\s+/g, ' ').trim().slice(0, 180)
-  const status = String(task.type?.name || task.task_type?.name || task.status || task.state || 'review').replace(/\s+/g, ' ').trim()
+  const status = String(task.type?.name || task.task_type?.name || task.status || task.state || (taskIsCompleted(task, completedTypeIds) ? 'completed' : 'review')).replace(/\s+/g, ' ').trim()
   const verification = /\bVerification:\s*([^\n]{1,180})/i.exec(evidence)?.[1]?.replace(/\s+/g, ' ').trim().replace(/[.]+$/, '') || ''
   const mention = requester ? `@${requester} ` : ''
   const slug = ticketDisplaySlug(task)
@@ -137,9 +145,9 @@ export function opencodeEventEvidence(event) {
   const command = String(input.command ?? input.cmd ?? '')
 
   const lowerTool = tool.toLowerCase()
-  const prefixed = /^(?:mcp__)?openvisio(?:-team|_team)(?:__|[_.:/-])(.+)$/i.exec(tool)
+  const prefixed = /^(?:mcp__)?openvisio(?:-team|_team)(?:-watcher|_watcher)?(?:__|[_.:/-])(.+)$/i.exec(tool)
   const bareTool = lowerTool.replace(/[-.]/g, '_')
-  const knownMcp = /^(?:get_ticket|list_tasks|list_task_types|update_ticket|post_message|comment_ticket|react_message|list_projects|list_agents|list_activity|list_codebases|create_codebase_branch|create_codebase_commit|write_codebase_file|create_pull_request)$/
+  const knownMcp = /^(?:get_ticket|list_tasks|list_task_types|update_ticket|post_message|create_task_comment|comment_ticket|react_message|list_projects|list_agents|list_activity|list_codebases|create_codebase_branch|create_codebase_commit|write_codebase_file|create_pull_request)$/
   const mcpTool = (prefixed?.[1] ? prefixed[1].replace(/[-.]/g, '_') : (knownMcp.test(bareTool) ? bareTool : '')).toLowerCase()
   const codebaseMutation = /^(?:create_codebase_branch|create_codebase_commit|write_codebase_file|create_pull_request)$/.test(mcpTool)
   const mutationTool = /^(?:edit|write|patch|apply_patch|multiedit|multi_edit)$/i.test(tool)
@@ -156,7 +164,7 @@ export function opencodeEventEvidence(event) {
     didRepoMutation: completed && (mutationTool || codebaseMutation || (bashTool && commandMutation)),
     didMcpTaskRead: completed && /^(?:get_ticket|list_tasks)$/.test(mcpTool),
     didMcpTaskUpdate: completed && mcpTool === 'update_ticket',
-    didMessage: completed && /^(?:post_message|comment_ticket)$/.test(mcpTool),
+    didMessage: completed && /^(?:post_message|create_task_comment|comment_ticket)$/.test(mcpTool),
     didChannelMessage: completed && mcpTool === 'post_message',
   }
 }
@@ -186,7 +194,7 @@ export function codexEventEvidence(event) {
   if (itemType !== 'mcp_tool_call') return {}
 
   const rawTool = String(item.tool ?? item.name ?? item.method ?? 'unknown')
-  const prefixed = /^(?:mcp__)?openvisio(?:-team|_team)(?:__|[_.:/-])(.+)$/i.exec(rawTool)
+  const prefixed = /^(?:mcp__)?openvisio(?:-team|_team)(?:-watcher|_watcher)?(?:__|[_.:/-])(.+)$/i.exec(rawTool)
   const mcpTool = String(prefixed?.[1] ?? rawTool).replace(/[-.]/g, '_')
   const succeeded = completed && !failed
   const resultText = item.result?.content?.find?.((part) => part?.type === 'text')?.text
@@ -201,7 +209,7 @@ export function codexEventEvidence(event) {
     didRepoMutation: succeeded && /^(?:create_codebase_branch|create_codebase_commit|write_codebase_file|create_pull_request)$/.test(mcpTool),
     didMcpTaskRead: succeeded && /^(?:get_ticket|list_tasks)$/.test(mcpTool),
     didMcpTaskUpdate: succeeded && mcpTool === 'update_ticket',
-    didMessage: succeeded && /^(?:post_message|comment_ticket)$/.test(mcpTool),
+    didMessage: succeeded && /^(?:post_message|create_task_comment|comment_ticket)$/.test(mcpTool),
     didChannelMessage: succeeded && mcpTool === 'post_message',
   }
 }
@@ -352,7 +360,7 @@ export function shouldSuppressCodexDiagnostic(value) {
 export function mentionDedupeKeys(message, channelId) {
   const m = message && typeof message === 'object' ? message : {}
   const id = m.message_id ?? m.messageId ?? m.id
-  const parent = m.parent_id ?? m.parentId ?? ''
+  const parent = messageParentId(m) ?? ''
   const text = String(m.content ?? m.body ?? m.text ?? m.message ?? '').replace(/\s+/g, ' ').trim().slice(0, 180)
   return {
     idKey: id != null ? `id:${id}` : '',
@@ -360,10 +368,46 @@ export function mentionDedupeKeys(message, channelId) {
   }
 }
 
+// Keep transport aliases consistent at intake, ownership verification and
+// delivery deduplication. Unknown objects are not usable thread identities.
+export function messageParentId(message) {
+  if (!message || typeof message !== 'object') return null
+  for (const key of ['parent_id', 'parentId', 'thread_id', 'threadId', 'reply_to', 'replyTo']) {
+    let value = message[key]
+    if (value && typeof value === 'object' && !Array.isArray(value)) value = value.message_id ?? value.messageId ?? value.id
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return value
+    if (typeof value === 'string' && /^\d+$/.test(value) && Number.isSafeInteger(Number(value)) && Number(value) > 0) return value
+  }
+  return null
+}
+
 export function normalizeRenderedMessageText(value) {
   return String(value || '').replace(/\s+/g, ' ').trim().toLowerCase()
 }
 
+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 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 : {})
+  const agentId = agent.id ?? agent.agent_id ?? row.agent_id ?? row.sender_agent_id ?? row.senderAgentId
+  const identifier = String(agent.identifier ?? agent.slug ?? row.agent_identifier ?? row.sender_identifier ?? '')
+  const name = String(agent.name ?? agent.display_name ?? (senderLooksLikeAgent ? sender.name : '') ?? '')
+  const aliases = new Set([identity.identifier, identity.slug, identity.name].map((item) => String(item || '').toLowerCase()).filter(Boolean))
+  const stableAliases = new Set([identity.identifier, identity.slug].map((item) => String(item || '').toLowerCase()).filter(Boolean))
+  const hasId = (id) => id != null && String(id).trim() !== ''
+  // Stable identifiers are authoritative. Display names may be recycled or
+  // shared with a teammate and cannot override a conflicting agent id.
+  const isSelf = hasId(identity.id) && hasId(agentId)
+    ? String(agentId) === String(identity.id)
+    : identifier && stableAliases.size
+      ? stableAliases.has(identifier.toLowerCase())
+      : aliases.has(identifier.toLowerCase()) || (!!expanded && !identifier && aliases.has(name.toLowerCase()))
+  return !!isSelf
+}
+
 // Extract only messages visibly authored by this agent from the backend's live
 // thread response. REST and WebSocket payloads use several sender shapes, so this
 // mirrors the frontend normalizer instead of trusting one field name.
@@ -376,25 +420,15 @@ export function renderedAgentMessages(value, identity = {}) {
     if (typeof node !== 'object') return
     const row = node
     const content = row.content ?? row.body ?? row.text ?? (typeof row.message === 'string' ? row.message : undefined)
-    const rowId = row.id ?? row.message_id ?? row.messageId
+    const rowId = row.message_id ?? row.messageId ?? row.id
     if (content != null && rowId != null) {
-      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 senderKind = String(sender.type ?? sender.kind ?? sender.sender_type ?? row.sender_type ?? row.author_type ?? '').toLowerCase()
-      const senderLooksLikeAgent = /agent|bot/.test(senderKind) || sender.agent_id != null || sender.identifier != null || (sender.slug != null && !sender.email)
-      const agent = expanded || (senderLooksLikeAgent ? sender : {})
-      const agentId = Number(agent.id ?? agent.agent_id ?? row.agent_id ?? row.sender_agent_id ?? row.senderAgentId ?? NaN)
-      const identifier = String(agent.identifier ?? agent.slug ?? row.agent_identifier ?? row.sender_identifier ?? '')
-      const name = String(agent.name ?? agent.display_name ?? (senderLooksLikeAgent ? sender.name : '') ?? '')
-      const aliases = new Set([identity.identifier, identity.slug, identity.name].map((item) => String(item || '').toLowerCase()).filter(Boolean))
-      const isSelf = (Number.isFinite(Number(identity.id)) && agentId === Number(identity.id)) || aliases.has(identifier.toLowerCase()) || (!!expanded && aliases.has(name.toLowerCase()))
-      if (isSelf) {
+      if (messageSenderIsSelf(row, identity)) {
         const key = String(rowId)
         if (!seen.has(key)) {
           seen.add(key)
           rows.push({
             id: rowId,
-            parentId: row.parent_id ?? row.parentId ?? row.thread_id ?? null,
+            parentId: messageParentId(row),
             content: String(content),
           })
         }
@@ -425,14 +459,14 @@ function conversationMentions(value, selfAliases) {
   for (const alias of aliases) {
     // A sentence-ending period is punctuation, while a period followed by a
     // handle character is still part of an alias such as `alex.morgan`.
-    const pattern = new RegExp(`@${escapeRegex(alias)}(?![a-z0-9_-]|\\.(?=[a-z0-9]))`, 'gi')
+    const pattern = new RegExp(`(?<![a-z0-9_@])@${escapeRegex(alias)}(?![a-z0-9_-]|\\.(?=[a-z0-9]))`, 'gi')
     for (const match of text.matchAll(pattern)) {
       const index = match.index ?? 0
       const end = index + match[0].length
       if (!self.some((item) => index >= item.index && end <= item.end)) self.push({ name: alias, index, end })
     }
   }
-  const other = [...text.matchAll(/@([a-z0-9](?:[a-z0-9_.-]*[a-z0-9_-])?)(?=$|[^a-z0-9_.-]|\.(?:\s|$))/gi)]
+  const other = [...text.matchAll(/(?<![a-z0-9_@])@([a-z0-9](?:[a-z0-9_.-]*[a-z0-9_-])?)(?=$|[^a-z0-9_.-]|\.(?:\s|$))/gi)]
     .map((match) => ({ name: cleanAlias(match[1]), index: match.index ?? 0, end: (match.index ?? 0) + match[0].length }))
     .filter((mention) => !self.some((item) => mention.index >= item.index && mention.end <= item.end))
   return { self, other, all: [...self, ...other].sort((a, b) => a.index - b.index) }
@@ -441,11 +475,15 @@ 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].find((item) => item && typeof item === 'object') || {}
+  const 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 /agent|bot/.test(kind) || sender.agent_id != null || sender.identifier != null || (sender.slug != null && !sender.email)
+  return agentSenderKind(kind) || (!humanSenderKind(kind) && (sender.agent_id != null || sender.identifier != null || (sender.slug != null && !sender.email)))
 }
 
+const agentSenderKind = (kind) => /(?:^|[_ -])(?:agent|bot)(?:$|[_ -])/.test(kind)
+const humanSenderKind = (kind) => /^(?:human|user|member|person)$/.test(kind)
+
 // WebSocket deployments may fan every reply in a watched thread as
 // `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
@@ -456,6 +494,8 @@ export function classifyConversationTarget(message, selfAliases, { threadOwned =
   const { self: selfMentions, other: otherMentions, all: mentions } = conversationMentions(text, selfAliases)
   const explicitSelf = selfMentions.length > 0
 
+  if (!text) return { action: 'ignore', reason: 'empty-message', text, explicitSelf, otherMentions: [] }
+
   if (messageSenderIsAgent(m) && !explicitSelf) {
     return { action: 'ignore', reason: 'other-agent-chatter', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
   }
@@ -463,8 +503,12 @@ export function classifyConversationTarget(message, selfAliases, { threadOwned =
     return { action: 'ignore', reason: 'explicit-other-recipient', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
   }
 
-  const standDown = /\b(?:do\s+not|don't|dont)\s+(?:pick|take|handle|work\s+on|start|continue)\b|\b(?:stand\s+down|stop\s+(?:working|handling|on\s+this)|leave\s+(?:this|it)\s+(?:alone|to\s+\S+)|cancel\s+(?:this|that|it)|not\s+(?:for|yours?))\b/i.test(text)
-  if (standDown && (explicitSelf || !mentions.length)) {
+  const standDown = /\b(?:do\s+not|don't|dont)\s+(?:pick|take|handle|work\s+on|start|continue|fix|implement|code)\b|\b(?:stand\s+down|stop\s+(?:working|handling|on\s+this)|leave\s+(?:this|it)\s+(?:alone|to\s+\S+)|cancel\s+(?:this|that|it)|not\s+(?:for|yours?))\b/i.test(text)
+  const readOnlyRequest = /\b(?:(?:just|only)\s+(?:list|check|tell|show)|status\s+only)\b/i.test(text)
+  const stopActiveWork = /\b(?:stand\s+down|stop\s+(?:working|handling|on\s+this)|cancel\s+(?:this|that|it)|leave\s+(?:this|it)\s+(?:alone|to\s+\S+)|(?:do\s+not|don't|dont)\s+(?:continue|handle|work\s+on))\b/i.test(text)
+  // “Just list my tickets, do not start” requests an answer with work pickup
+  // disabled. An instruction to stop active work still takes precedence.
+  if (standDown && (!readOnlyRequest || stopActiveWork) && (explicitSelf || (threadOwned && !mentions.length))) {
     return { action: 'stand_down', reason: 'explicit-stand-down', text, explicitSelf, otherMentions: otherMentions.map((item) => item.name) }
   }
 
@@ -489,15 +533,22 @@ export function classifyConversationTarget(message, selfAliases, { threadOwned =
 // own describe plenty of product conversations and must not start a coding lane.
 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|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)
-  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
+  // Negation scopes the following instruction, not every independent request
+  // in the message. “Fix the component; don't deploy” still requests a fix.
+  const clauses = text.split(/[;!?]|\b(?:but|however|instead)\b/i)
+  return clauses.some((clause) => {
+    const positive = clause.split(/\b(?:do\s+not|don't|dont|stand\s+down|stop\s+(?:working|handling|on\s+this)|cancel\s+(?:this|that|it|the\s+(?:task|ticket)))\b/i)[0]
+    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(positive)
+    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(positive)
+    const contextualRepair = /\b(?:fix|debug|repair|rebuild|rerun|run\s+(?:the\s+)?(?:build|tests?))\b/i.test(positive) && /\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) {
-  const text = String(value || '').replace(/\s+/g, ' ').trim()
+  // Project prefixes such as OPEN-77 are identifiers, not the word “open”.
+  // A question about a finished ticket must not become a backlog pickup.
+  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)
@@ -509,7 +560,7 @@ export function conversationAsksPendingTickets(value) {
 // precise, scoped answer (or say which live fact it could not read). Failed team
 // mutations remain fail-closed so prose can never masquerade as a completed act.
 export function blockingReplyMcpErrors(errors) {
-  const mutation = /^(?:update_ticket|post_message|comment_ticket|react_message|create_codebase_branch|create_codebase_commit|write_codebase_file|create_pull_request)$/
+  const mutation = /^(?:update_ticket|post_message|create_task_comment|comment_ticket|react_message|create_codebase_branch|create_codebase_commit|write_codebase_file|create_pull_request)$/
   return [...new Set((Array.isArray(errors) ? errors : []).map((name) => String(name || '').replace(/^.*(?:__|[.:/])/, '').replace(/[-.]/g, '_').toLowerCase()).filter((name) => mutation.test(name)))]
 }
 
@@ -539,7 +590,7 @@ export function requestTargetsLaterAgent(text, selfAliases) {
 
   const bridge = value.slice(self.end, later.index).toLowerCase()
   const suffix = value.slice(later.end).trim().toLowerCase()
-  const shared = /\b(?:and|with|alongside)\s*$/.test(bridge.trim()) && /\b(?:both|together|you (?:two|all)|everyone)\b/.test(suffix)
+  const shared = /^(?:\s*[,;:]?\s*)(?:and|with|alongside|&)\s*$/.test(bridge)
   if (shared) return false
-  return /\?|^(?:[,.:;-]\s*)?(?:please\s+)?(?:can|could|would|will|do|write|create|make|send|fix|check|review|prepare|give|tell|help|handle|take|move|update|implement)\b/i.test(suffix)
+  return /^(?:[,.:;-]\s*)?(?:please\s+)?(?:can|could|would|will|do|write|create|make|send|fix|check|review|prepare|give|tell|help|handle|take|move|update|implement)\b/i.test(suffix)
 }