openvisio-agent 0.19.0 → 0.19.2

package/README.md

@@ -58,13 +58,15 @@ Runs the **autonomy loop** — the agent replies to @mentions and picks up ticke
 
 Codex and OpenCode cycles run through Mastra's ACP harness. Codex uses the packaged `codex-acp` adapter and reuses the machine's existing ChatGPT/Codex login; OpenCode uses its native `opencode acp` server. Each accepted ticket gets its own ACP session and worktree. Mastra Memory stores ticket/thread context in local libSQL under `~/.openvisio/`, while a compact JSON ledger retains only exact replay, cancellation, and delivery keys.
 
+Model names are negotiated at session start. Codex and OpenCode match the configured name against the models advertised by ACP, preferring the same family and reasoning effort (`medium` for an unsuffixed family); provider-qualified and nearby generation names are resolved automatically. Claude versioned names are normalized to its stable `sonnet`, `opus`, `haiku`, or `fable` aliases and use the CLI's native ordered fallback chain.
+
 Backend/BYO watchers reconcile immediately whenever the process starts or the WebSocket connects. 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 assigned tasks and recent mention activity missed while offline. Optional actions such as ticket comments are used only when advertised; their absence cannot strand a completed ticket in a retry loop. The same zero-model check runs every five minutes as a safety net; a model starts only when pending work exists.
 
 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 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.0",
+  "version": "0.19.2",
   "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

@@ -32,6 +32,7 @@ const cli = readFileSync(join(root, 'bin', 'cli.mjs'), 'utf8')
 const websocket = readFileSync(join(root, 'src', 'ws.mjs'), 'utf8')
 const cycleQueue = readFileSync(join(root, 'src', 'cycle-queue.mjs'), 'utf8')
 const mastraHarness = readFileSync(join(root, 'src', 'mastra-harness.mjs'), 'utf8')
+const modelSelection = readFileSync(join(root, 'src', 'model-selection.mjs'), 'utf8')
 const activityHook = readFileSync(join(repo, 'frontend', 'hooks', 'useAgentActivity.ts'), 'utf8')
 const taskHook = readFileSync(join(repo, 'frontend', 'hooks', 'useBackendTasks.ts'), 'utf8')
 const liveTasks = readFileSync(join(repo, 'frontend', 'lib', 'collab', 'liveTasks.ts'), 'utf8')
@@ -55,7 +56,8 @@ 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')],
   ['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')],
@@ -74,6 +76,7 @@ const assertions = [
   ['MCP requests have a deadline including response bodies', mcpHttp.includes('controller.abort()') && mcpHttp.includes('const body = await res.text()')],
   ['Mastra memory uses real ticket and thread identities', watcher.includes('createMastraMemory') && watcher.includes('await memory.context(memoryRefs)') && memory.includes('new Memory({ storage') && memory.includes('new LibSQLStore') && memory.includes('ticket:${refs.projectId}:${refs.ticketId}') && memory.includes('channel:${refs.channelId}:thread:')],
   ['Codex and OpenCode use isolated Mastra ACP sessions', watcher.includes('createMastraAcpRunner') && mastraHarness.includes('new AcpAgentClass') && mastraHarness.includes('persistSession: false') && mastraHarness.includes("runtime: 'mastra-acp'")],
+  ['runtime models are resolved before work starts', mastraHarness.includes('getAvailableModels()') && mastraHarness.includes('resolveAvailableModel(requestedModel') && mastraHarness.includes('await acp.setModel(selectedModel)') && modelSelection.includes("const DEFAULT_EFFORT = 'medium'") && watcher.includes('resolveClaudeModel') && watcher.includes("'--fallback-model'" )],
   ['one watcher owns isolated concurrent work and serial reply runtimes', watcher.includes('MAX_CONCURRENT_WORKERS = 3') && watcher.includes('createWorkRunner(item.control, item.workdir)') && watcher.includes('const replyRunner = createCycleRunner')],
   ['workers serialize shared worktrees while independent worktrees run concurrently', watcher.includes('groupKey: (item) => item.workdir || workdir') && cycleQueue.includes('active.size < concurrency') && cycleQueue.includes('activeGroups.has(entry.group)')],
   ['work and reply cancellation targets are isolated', watcher.includes('item.control.cancelled = true') && watcher.includes('item.control.runner?.cancelCurrent')],

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/mastra-harness.mjs

@@ -2,6 +2,7 @@ import { spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { AcpAgent } from '@mastra/acp'
 import { onPath } from './lib.mjs'
+import { resolveAvailableModel } from './model-selection.mjs'
 
 const MCP_TOOL_NAMES = [
   'list_agents', 'list_projects', 'list_tasks', 'list_task_types', 'get_ticket',
@@ -97,7 +98,6 @@ export function createMastraAcpRunner({
         mcpServers,
       },
       persistSession: false,
-      ...(cycleModel || model ? { model: cycleModel || model } : {}),
       onPermissionRequest: async ({ options }) => {
         const kind = canCode ? 'allow_once' : 'reject_once'
         const selected = options.find((option) => option.kind === kind) || options.find((option) => option.kind.startsWith(canCode ? 'allow' : 'reject'))
@@ -114,9 +114,22 @@ export function createMastraAcpRunner({
       }) : undefined,
     })
     active = { acp, controller }
-    const timer = setTimeout(() => { timedOut = true; controller.abort() }, maxCycleMs)
-    log(`running ${agent} cycle via Mastra ACP…${cycleModel || model ? ` [${cycleModel || model}]` : ''}`)
+    const timer = setTimeout(() => { timedOut = true; controller.abort(); acp.connection.disconnect() }, maxCycleMs)
+    const requestedModel = cycleModel || model || ''
+    let selectedModel = ''
     try {
+      if (requestedModel) {
+        const availableModels = await acp.getAvailableModels()
+        const resolution = resolveAvailableModel(requestedModel, availableModels)
+        selectedModel = resolution.selected
+        if (selectedModel) {
+          await acp.setModel(selectedModel)
+          if (selectedModel !== requestedModel) log(`model ${requestedModel} resolved to available ${selectedModel} [${resolution.reason}]`)
+        } else {
+          log(`model ${requestedModel} could not be negotiated because ${agent} did not advertise selectable models; using its session default`)
+        }
+      }
+      log(`running ${agent} cycle via Mastra ACP…${selectedModel || requestedModel ? ` [${selectedModel || requestedModel}]` : ' [runtime default]'}`)
       const fullPrompt = systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt
       for await (const event of acp.connection.promptStream(fullPrompt, controller.signal)) {
         if (event.type === 'text') { outputText += event.text; continue }
@@ -152,7 +165,7 @@ export function createMastraAcpRunner({
       didResultMessage = didChannelMessage && didRepoMutation
       log(`${agent} cycle done via Mastra ACP (ok)`)
       return {
-        type: 'result', subtype: 'ok', runtime: 'mastra-acp', outputText: outputText.trim(),
+        type: 'result', subtype: 'ok', runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),
         mcpCalls: [...calls], mcpErrors: [...errors.keys()], mcpErrorDetails: Object.fromEntries(errors),
         didCode, didRepoMutation, didMessage, didChannelMessage, didResultMessage,
         didMcpTaskRead, didMcpTaskUpdate,
@@ -162,7 +175,7 @@ export function createMastraAcpRunner({
       const subtype = timedOut ? 'timeout' : canceled ? 'canceled' : 'error'
       log(`${agent} cycle done via Mastra ACP (${subtype}${!canceled && error?.message ? ': ' + clean(error.message) : ''})`)
       return {
-        type: 'result', subtype, runtime: 'mastra-acp', outputText: outputText.trim(),
+        type: 'result', subtype, runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),
         mcpCalls: [...calls], mcpErrors: [...errors.keys()], mcpErrorDetails: Object.fromEntries(errors),
         didCode, didRepoMutation, didMessage, didChannelMessage, didResultMessage,
         didMcpTaskRead, didMcpTaskUpdate,
@@ -178,6 +191,7 @@ export function createMastraAcpRunner({
     if (!active) return
     active.controller.abort()
     try { await active.acp.connection.cancel() } catch { /* already stopped */ }
+    active.acp.connection.disconnect()
   }
 
   log(`${agent} Mastra ACP runner ready${canCode ? ` [CODE workspace ${defaultCwd}]` : ' [CHAT-ONLY]'}`)

package/src/model-selection.mjs

@@ -0,0 +1,75 @@
+const EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra']
+const DEFAULT_EFFORT = 'medium'
+
+const text = (value) => String(value ?? '').trim()
+const lower = (value) => text(value).toLowerCase()
+
+function parts(value) {
+  const raw = text(value)
+  const effortMatch = /\[([^\]]+)\]$/.exec(raw)
+  const withoutEffort = effortMatch ? raw.slice(0, effortMatch.index) : raw
+  const path = lower(withoutEffort).split('/').filter(Boolean)
+  const leaf = path.at(-1) || ''
+  const tokens = leaf.split(/[^a-z0-9]+/).filter(Boolean)
+  return { raw, id: lower(raw), base: lower(withoutEffort), leaf, tokens, provider: path.slice(0, -1).join('/'), effort: lower(effortMatch?.[1]) }
+}
+
+const effortDistance = (actual, preferred) => {
+  const actualIndex = EFFORTS.indexOf(actual)
+  const preferredIndex = EFFORTS.indexOf(preferred)
+  if (actualIndex < 0) return 20
+  return Math.abs(actualIndex - (preferredIndex < 0 ? EFFORTS.indexOf(DEFAULT_EFFORT) : preferredIndex))
+}
+
+function similarity(requested, candidate, preferredEffort) {
+  if (candidate.id === requested.id) return 100_000
+  let score = 0
+  if (candidate.base === requested.base || candidate.leaf === requested.leaf) score += 50_000
+  if (requested.provider && candidate.provider === requested.provider) score += 2_000
+  const requestedTokens = new Set(requested.tokens)
+  const shared = candidate.tokens.filter((token) => requestedTokens.has(token)).length
+  score += shared * 1_000
+  if (requested.leaf && (candidate.leaf.includes(requested.leaf) || requested.leaf.includes(candidate.leaf))) score += 10_000
+  let prefix = 0
+  while (prefix < requested.leaf.length && prefix < candidate.leaf.length && requested.leaf[prefix] === candidate.leaf[prefix]) prefix++
+  score += prefix * 10
+  score -= effortDistance(candidate.effort, requested.effort || preferredEffort) * 100
+  return score
+}
+
+export function resolveAvailableModel(requestedValue, availableModels = [], { preferredEffort = DEFAULT_EFFORT } = {}) {
+  const requested = parts(requestedValue)
+  const choices = availableModels.map((entry) => typeof entry === 'string' ? entry : entry?.modelId).map(text).filter(Boolean)
+  if (!choices.length) return { requested: requested.raw, selected: '', reason: 'runtime-default', available: [] }
+  if (!requested.raw) return { requested: '', selected: '', reason: 'runtime-default', available: choices }
+
+  const ranked = choices.map((id, index) => {
+    const candidate = parts(id)
+    return { id, index, score: similarity(requested, candidate, preferredEffort) }
+  }).sort((a, b) => b.score - a.score || a.index - b.index)
+  const winner = ranked[0]
+  return {
+    requested: requested.raw,
+    selected: winner.id,
+    reason: lower(winner.id) === requested.id ? 'exact' : parts(winner.id).base === requested.base || parts(winner.id).leaf === requested.leaf ? 'family-effort' : 'nearest',
+    available: choices,
+  }
+}
+
+const CLAUDE_FAMILIES = ['sonnet', 'opus', 'haiku', 'fable']
+
+export function resolveClaudeModel(requestedValue) {
+  const requested = lower(requestedValue)
+  if (!requested) return ''
+  const family = CLAUDE_FAMILIES.find((name) => requested === name || requested.startsWith('claude-') && requested.includes(name))
+  return family || text(requestedValue)
+}
+
+export function claudeFallbackModels(selectedValue) {
+  const selected = lower(selectedValue)
+  const preferred = selected === 'opus' ? ['sonnet', 'haiku']
+    : selected === 'haiku' ? ['sonnet', 'opus']
+      : selected === 'fable' ? ['sonnet', 'opus'] : ['opus', 'haiku']
+  return preferred.filter((model) => model !== selected)
+}
+

package/src/watch.mjs

@@ -20,6 +20,7 @@ import { buildCodexMcpOverride } from './codex-config.mjs'
 import { createCycleQueue } from './cycle-queue.mjs'
 import { modelProcessOptions, stopModelProcess } from './process-lifecycle.mjs'
 import { createMastraAcpRunner } from './mastra-harness.mjs'
+import { claudeFallbackModels, resolveClaudeModel } from './model-selection.mjs'
 
 function findTicketWorktree(workspaceRoot, ticketId) {
   if (!workspaceRoot || ticketId == null) return ''
@@ -613,7 +614,7 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
   // The model the CURRENT session was spawned with. runCycle can pass a different
   // model per cycle (cheap for chat, stronger for code) — a change recycles the
   // session so the new model takes effect.
-  let sessionModel = model || null
+  let sessionModel = resolveClaudeModel(model) || null
   let turnsThisSession = 0
   let sessionStartedAt = 0
   let resolveTurn = null
@@ -670,7 +671,8 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
     if (!mcpConfig) { log('WARNING: no MCP config — the agent can react to events but has no tools to act. Re-connect with --mcp-url.') }
     // The charter + creds ride in the system prompt (cacheable → not re-billed each
     // cycle), leaving only the small per-cycle instruction in the user message.
-    const base = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--strict-mcp-config', '--mcp-config', mcpConfig, ...(sessionModel ? ['--model', sessionModel] : []), ...(systemPrompt ? ['--append-system-prompt', systemPrompt] : [])]
+    const fallbackModels = claudeFallbackModels(sessionModel)
+    const base = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--strict-mcp-config', '--mcp-config', mcpConfig, ...(sessionModel ? ['--model', sessionModel, ...(fallbackModels.length ? ['--fallback-model', fallbackModels.join(',')] : [])] : []), ...(systemPrompt ? ['--append-system-prompt', systemPrompt] : [])]
     const args = canCode ? [...base, '--allowedTools', ...CODE_TOOLS, '--disallowedTools', ...DENY_TOOLS] : [...base, '--allowedTools', 'mcp__openvisio-team__*']
     const c = spawn(claude, args, { ...modelProcessOptions, cwd: workdir || undefined, stdio: ['pipe', 'pipe', 'inherit'] })
     child = c
@@ -731,9 +733,11 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
     return new Promise((resolve) => {
       // A per-cycle model override (e.g. chat on a cheaper model than code) — a
       // change means the warm session must be respawned with the new --model.
-      if (cycleModel && cycleModel !== sessionModel) {
-        if (child) { log('model change ' + (sessionModel || 'default') + ' → ' + cycleModel + ' — recycling session'); try { child.kill() } catch { /* gone */ } child = null }
-        sessionModel = cycleModel
+      const resolvedCycleModel = resolveClaudeModel(cycleModel)
+      if (resolvedCycleModel && resolvedCycleModel !== sessionModel) {
+        if (child) { log('model change ' + (sessionModel || 'default') + ' → ' + resolvedCycleModel + ' — recycling session'); try { child.kill() } catch { /* gone */ } child = null }
+        if (resolvedCycleModel !== cycleModel) log('model ' + cycleModel + ' resolved to Claude family alias ' + resolvedCycleModel)
+        sessionModel = resolvedCycleModel
       }
       if (child && (turnsThisSession >= MAX_TURNS || Date.now() - sessionStartedAt > SESSION_IDLE_MS)) {
         log('recycling session (turns=' + turnsThisSession + ')')
@@ -1705,11 +1709,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
@@ -1720,8 +1734,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')