openvisio-agent 0.16.2 → 0.17.0

package/README.md

@@ -58,6 +58,8 @@ Runs the **autonomy loop** — the agent replies to @mentions and picks up ticke
 
 Backend/BYO watchers reconcile immediately whenever the process starts or the WebSocket connects. A direct MCP session uses the backend's actual tools (`list_agents`, `list_projects`, `list_tasks`, `list_task_types`, and `list_activity`) to recover assigned tasks and recent mention activity missed while offline. The same zero-model check runs every five minutes as a safety net; a model starts only when pending work exists.
 
+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.
+
 Claude uses Haiku for routine coordination and Sonnet for repository work. Codex uses `gpt-5.6-sol` for every cycle, including messages, mentions, triage, board movement, MCP calls, and coding. This intentionally favors reliability and consistent tool use over the cheaper Codex tiers.
 
 ```bash

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "openvisio-agent",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "description": "Connect Claude Code, Codex, or OpenCode to an OpenVisio team — MCP tools + optional autonomy — in one command.",
   "type": "module",
   "bin": {
     "openvisio-agent": "bin/cli.mjs"
   },
   "scripts": {
-    "test": "node --test"
+    "test": "node --test",
+    "certify": "node scripts/certify.mjs"
   },
   "files": [
     "bin",
+    "scripts",
     "src",
     "README.md"
   ],

package/scripts/certify.mjs

@@ -0,0 +1,49 @@
+import { readFileSync, readdirSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..')
+const repo = join(root, '..', '..')
+const failures = []
+
+function run(label, command, args, cwd = root) {
+  const result = spawnSync(command, args, { cwd, encoding: 'utf8', env: { ...process.env, npm_config_cache: '/private/tmp/openvisio-npm-cache' } })
+  if (result.status !== 0) failures.push(`${label}\n${result.stdout || ''}${result.stderr || ''}`)
+  else process.stdout.write(`✓ ${label}\n`)
+}
+
+for (const file of readdirSync(join(root, 'src')).filter((name) => name.endsWith('.mjs'))) run(`syntax ${file}`, process.execPath, ['--check', join(root, 'src', file)])
+for (const file of readdirSync(join(root, 'bin')).filter((name) => name.endsWith('.mjs'))) run(`syntax ${file}`, process.execPath, ['--check', join(root, 'bin', file)])
+run('unit and behavior tests', process.execPath, ['--test'])
+run('frontend typecheck', 'npm', ['run', 'typecheck'], join(repo, 'frontend'))
+run('package dry run', 'npm', ['pack', '--dry-run'])
+run('diff whitespace check', 'git', ['diff', '--check'], repo)
+
+const watcher = readFileSync(join(root, 'src', 'watch.mjs'), 'utf8')
+const websocket = readFileSync(join(root, 'src', 'ws.mjs'), 'utf8')
+const activityHook = readFileSync(join(repo, 'frontend', 'hooks', 'useAgentActivity.ts'), 'utf8')
+const spec = readFileSync(join(repo, 'docs', 'CODEX_BYO_AGENT_SPEC.md'), 'utf8')
+
+const assertions = [
+  ['task:assigned is handled', watcher.includes("k === 'task:assigned'")],
+  ['task signals are verified with get_ticket', watcher.includes("callMcpTool('get_ticket'")],
+  ['two internal lanes exist', watcher.includes('work: createCycleRunner') && watcher.includes('reply: createCycleRunner')],
+  ['activity uses REST endpoint', watcher.includes('agentStateRequest(')],
+  ['websocket client cannot emit legacy agent_status', !websocket.includes('agent_status')],
+  ['frontend consumes thinking event', activityHook.includes("'channel:agent:thinking'")],
+  ['frontend consumes working event', activityHook.includes("'channel:agent:working'")],
+  ['frontend consumes typing event', activityHook.includes("'channel:agent:typing'")],
+  ['completion has an evidence failure gate', watcher.includes('WORK_CYCLE_FAILED')],
+  ['normative certification gates are documented', spec.includes('## Mandatory certification gates')],
+]
+for (const [label, ok] of assertions) {
+  if (!ok) failures.push(label)
+  else process.stdout.write(`✓ ${label}\n`)
+}
+
+if (failures.length) {
+  process.stderr.write(`\nCERTIFICATION FAILED (${failures.length})\n\n${failures.join('\n\n')}\n`)
+  process.exit(1)
+}
+process.stdout.write('\nCERTIFICATION PASSED\n')

package/src/events.mjs

@@ -34,6 +34,20 @@ export function taskIsCompleted(task, completedTypeIds = new Set()) {
   return /\b(?:done|complete|completed|closed|cancelled|canceled|archived|resolved)\b/i.test(state)
 }
 
+export function agentStateRequest(backend, channelId, state, apiKey, identifier) {
+  if (!['thinking', 'working', 'typing'].includes(state)) throw new Error('invalid agent state')
+  const id = Number(channelId)
+  if (!Number.isFinite(id)) throw new Error('invalid channel id')
+  return {
+    url: String(backend || '').replace(/\/+$/, '') + `/channels/${id}/agent-state`,
+    init: {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', accept: 'application/json', 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier },
+      body: JSON.stringify({ state }),
+    },
+  }
+}
+
 // A mention event means this agent's name appeared somewhere, not necessarily
 // that the request was addressed to it. Reject a later-agent hand-off before a
 // model starts, while keeping explicitly shared requests addressed to both.

package/src/watch.mjs

@@ -10,7 +10,7 @@ import { homedir } from 'node:os'
 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 { requestTargetsLaterAgent, taskAgentId, taskFromEvent, taskIsCompleted } from './events.mjs'
+import { agentStateRequest, requestTargetsLaterAgent, taskAgentId, taskFromEvent, taskIsCompleted } from './events.mjs'
 
 // Behaviour prompts. The openvisio-team MCP bridge requires the agent's
 // credentials as ARGUMENTS on every tool call — those are injected at runtime by
@@ -247,6 +247,7 @@ export async function runWatch({ flags }) {
   // of REST-polling the frontend relay. Detected by the saved mode / a --ws flag.
   const backendMode = (saved && saved.mode === 'backend') || !!flags.ws
   if (backendMode) {
+    const backend = stripSlash(flags.backend || (saved && saved.backend) || '')
     const wsUrl = stripSlash(flags.ws || (saved && saved.wsUrl) || '')
     const apiKey = String(flags.key || (saved && saved.apiKey) || '')
     const identifier = String(flags.id || (saved && saved.identifier) || '')
@@ -254,7 +255,7 @@ export async function runWatch({ flags }) {
     if (!apiKey || !identifier) fail('No saved backend credentials for that agent.\n  Run `openvisio-agent connect --backend …` first, or pass --key and --id.')
     assertWebSocket(fail)
     if (flags.install) return installService({ slug: slug || 'openvisio', claude, mcpConfig, workdir })
-    return loopBackendWs({ wsUrl, apiKey, identifier, slug: slug || 'openvisio', claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug: !!flags.debug })
+    return loopBackendWs({ backend, wsUrl, apiKey, identifier, slug: slug || 'openvisio', claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug: !!flags.debug })
   }
 
   const host = stripSlash(flags.host || (saved && saved.host) || '')
@@ -326,7 +327,7 @@ function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, ma
 // line. That avoids inheriting unrelated user MCP servers while keeping the
 // user's normal Codex authentication. We deliberately never use Codex's dangerous
 // approval/sandbox bypass flag.
-function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, log, debug, model, systemPrompt }) {
+function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, log, debug, model, onTool, systemPrompt }) {
   const bin = onPath('codex') || 'codex'
   const cwd = workdir || OV_DIR
   const tomlString = (v) => JSON.stringify(String(v))
@@ -353,7 +354,7 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
         clearTimeout(timer)
         const calls = [...mcpCalls]
         log('codex MCP calls: ' + (calls.length ? calls.join(', ') : 'none') + (mcpErrors.size ? ' (failed: ' + [...mcpErrors].join(', ') + ')' : ''))
-        resolve({ ...o, didCode, didRepoMutation, didMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, outputText })
+        resolve({ ...o, didCode, didRepoMutation, didMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, mcpErrors: [...mcpErrors], outputText })
       }
       const inspectLine = (line) => {
         const s = line.trim()
@@ -368,6 +369,7 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
           if (item?.type === 'mcp_tool_call') {
             const tool = String(item.tool || item.name || item.method || 'unknown').replace(/^openvisio-team[.:/]/, '')
             mcpCalls.add(tool)
+            try { onTool && onTool(tool) } catch { /* activity is best-effort */ }
             if (/^(?:get_ticket|list_tasks|list_task_types)$/.test(tool)) didMcpTaskRead = true
             if (tool === 'update_ticket') didMcpTaskUpdate = true
             if (/post_message|comment_ticket/.test(tool)) didMessage = true
@@ -415,7 +417,7 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
   // opencode drives cycles differently — a headless `opencode run` per cycle rather
   // than a persistent stream-json session. Same { runCycle, canCode } contract.
   if (agent === 'opencode') return createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, maxCycleMs, log, debug, model, systemPrompt })
-  if (agent === 'codex') return createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, log, debug, model, systemPrompt })
+  if (agent === 'codex') return createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, log, debug, model, onTool, systemPrompt })
   let child = null
   // 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
@@ -526,17 +528,29 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
 // over the WS; each pushes ONE Claude cycle. Serialized (one cycle at a time) — events
 // arriving while busy are coalesced into a single follow-up cycle so a burst doesn't
 // stack up N sessions. Plus a one-time intro on first connect and a daily catch-up sweep.
-function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug }) {
+function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug }) {
   const log = (m) => process.stdout.write('[ws ' + new Date().toISOString() + '] ' + m + '\n')
   let handle = null
-  let statusEnabled = true
-  let lastStatusSentAt = 0
+  const statusBackoff = new Map()
   // Channels the agent is actively working in this cycle — drives the live
-  // agent:status broadcast (thinking → working → typing → done).
+  // Agent state is an authenticated REST call. The backend then fans out the
+  // documented channel:agent:* event to the app; it is never a WS client frame.
   const statusTargets = new Set()
   const sendStatus = (channelId, state) => {
-    if (!statusEnabled) return
-    try { if (handle) { lastStatusSentAt = Date.now(); handle.sendStatus(channelId, state) } } catch { /* best-effort */ }
+    if (!backend || !['thinking', 'working', 'typing'].includes(state)) return
+    const key = Number(channelId)
+    if ((statusBackoff.get(key) || 0) > Date.now()) return
+    let request
+    try { request = agentStateRequest(backend, key, state, apiKey, identifier) } catch { return }
+    void fetch(request.url, request.init).then(async (res) => {
+      if (res.ok) { statusBackoff.delete(key); return }
+      const body = (await res.text().catch(() => '')).replace(/\s+/g, ' ').slice(0, 160)
+      statusBackoff.set(key, Date.now() + 30_000)
+      log(`agent state HTTP ${res.status}${body ? ': ' + body : ''}; backing off 30s`)
+    }).catch((e) => {
+      statusBackoff.set(key, Date.now() + 30_000)
+      log('agent state request failed: ' + (e?.message || e) + '; backing off 30s')
+    })
   }
   const emitStatus = (state) => { for (const c of statusTargets) sendStatus(c, state) }
   const canCode = !!workdir
@@ -594,6 +608,7 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
   let lastTaskSignature = ''
   let lastTaskTriggeredAt = 0
   let lastInboxSignature = ''
+  let selfAgentId = null
   let mcpSessionId = ''
   let mcpRpcId = 0
 
@@ -618,7 +633,7 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
   }
   const ensureMcpSession = async () => {
     if (mcpSessionId) return
-    const res = await mcpPost({ jsonrpc: '2.0', id: ++mcpRpcId, method: 'initialize', params: { protocolVersion: '2025-03-26', capabilities: {}, clientInfo: { name: 'openvisio-agent', version: '0.16.2' } } }, false)
+    const res = await mcpPost({ jsonrpc: '2.0', id: ++mcpRpcId, method: 'initialize', params: { protocolVersion: '2025-03-26', capabilities: {}, clientInfo: { name: 'openvisio-agent', version: '0.17.0' } } }, false)
     if (!res.ok) throw new Error('MCP initialize HTTP ' + res.status)
     await mcpPayload(res)
     mcpSessionId = res.headers.get('mcp-session-id') || ''
@@ -658,6 +673,7 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
       const agents = Array.isArray(agentsData.agents) ? agentsData.agents : []
       const self = agents.find((a) => String(a.identifier || a.slug || '') === identifier)
       if (!self?.id) throw new Error('list_agents did not return this BYO agent')
+      selfAgentId = Number(self.id)
       const projectsData = toolData(await callMcpTool('list_projects'))
       const projects = Array.isArray(projectsData.projects) ? projectsData.projects : []
       const assigned = []
@@ -673,7 +689,7 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
           const taskAgentId = Number(task.agent_id ?? task.agentId ?? task.agent?.id)
           const taskIdent = String(task.agent?.identifier ?? task.agent?.slug ?? '')
           if (!taskIsCompleted(task, doneIds) && (taskAgentId === Number(self.id) || taskIdent === identifier)) {
-            assigned.push({ id: task.id, projectId: project.id, project: project.name, title: task.title, priority: task.priority, typeId: task.type_id ?? task.typeId })
+            assigned.push({ id: task.id, projectId: project.id, project: project.name, title: task.title, priority: task.priority, typeId: task.type_id ?? task.typeId, updatedAt: task.updated_at ?? task.updatedAt })
           }
         }
         const activities = Array.isArray(activityData.activities) ? activityData.activities : Array.isArray(activityData.activity) ? activityData.activity : []
@@ -696,8 +712,10 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
         if (signature !== lastTaskSignature || retryDue) {
           lastTaskSignature = signature
           lastTaskTriggeredAt = Date.now()
-          log('backlog reconciliation found ' + assigned.length + ' assigned task(s) -> coding cycle')
-          void drain('full', `Backlog reconciliation verified these open tasks are assigned to YOU: ${JSON.stringify(assigned)}. Start with the highest-priority/oldest one immediately. This is backlog-only work with NO source message or requester thread: do NOT post_message and do not announce progress or completion in any channel. Use get_ticket if more detail is needed, move it to the active column with update_ticket, complete the repository work, verify it, open the PR, then update the ticket with the evidence and move it to done when appropriate.`)
+          const priorityRank = { critical: 0, high: 1, medium: 2, low: 3 }
+          const next = [...assigned].sort((a, b) => (priorityRank[a.priority] ?? 9) - (priorityRank[b.priority] ?? 9) || String(a.updatedAt || '').localeCompare(String(b.updatedAt || '')))[0]
+          log('backlog reconciliation found ' + assigned.length + ' assigned task(s); queueing only ticket #' + next.id)
+          void drain('full', `Backlog reconciliation verified this open ticket is assigned to YOU: ${JSON.stringify(next)}. Process this ONE ticket only. This is backlog-only work with NO source message or requester thread: do NOT post_message and do not announce progress or completion in any channel. Call get_ticket, use list_task_types and update_ticket to move it active, complete and verify the work, open the PR, then update the ticket with evidence and move it to done when appropriate.`)
         }
       }
       const inboxSignature = JSON.stringify(mentionActivity.slice(-20)).slice(0, 4000)
@@ -737,19 +755,26 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
     const heartbeat = targets.length ? setInterval(() => emitStatus('working'), 9000) : null
     try {
       const result = await runners[laneName].runCycle(prompt, useModel)
-      // A zero exit is not proof of work. Assigned-ticket cycles must both use
-      // the task MCP and leave repository evidence. A simple `ls` no longer
-      // counts as completion. Do not retry a verified real blocker.
-      const legitimateNoWork = /\b(?:no (?:open |assigned |pending )?tasks?|not assigned to (?:me|you)|assigned to (?:another|someone else)|blocked|cannot|can't|missing|need access|permission|unclear)\b/i.test(result?.outputText || '')
-      const incomplete = !result?.didRepoMutation || !result?.didMcpTaskRead || !result?.didMcpTaskUpdate
-      if (agent === 'codex' && kind === 'full' && result?.subtype === 'ok' && incomplete && !legitimateNoWork) {
-        const missing = [!result.didMcpTaskRead && 'read the ticket through get_ticket/list_tasks', !result.didRepoMutation && 'perform and verify the repository change', !result.didMcpTaskUpdate && 'update the ticket through update_ticket'].filter(Boolean)
+      // Model prose never proves success or a blocker. Full cycles must produce
+      // runtime-observed ticket reads, repository evidence, and ticket updates.
+      const ticketCycle = /ticket\s+#?\d+.*?project\s+\d+/i.test(prompt)
+      const incomplete = !result?.didRepoMutation || (ticketCycle && (!result?.didMcpTaskRead || !result?.didMcpTaskUpdate)) || result?.mcpErrors?.length
+      if (agent === 'codex' && kind === 'full' && result?.subtype === 'ok' && incomplete) {
+        const missing = [ticketCycle && !result.didMcpTaskRead && 'read the ticket through get_ticket/list_tasks', !result.didRepoMutation && 'perform and verify the repository change', ticketCycle && !result.didMcpTaskUpdate && 'update the ticket through update_ticket'].filter(Boolean)
+        if (result.mcpErrors?.length) missing.push('resolve failed MCP calls: ' + result.mcpErrors.join(', '))
         log('coding cycle incomplete; recovery requires: ' + missing.join(', '))
-        await runners.work.runCycle(`The assigned task is NOT complete. Missing evidence: ${missing.join('; ')}. Do not post another acknowledgement or plan. Resume now. First use get_ticket/list_tasks and list_task_types, then do the repository work, verify it, commit and push an agent/* branch, open the PR, call update_ticket with the correct board column, and post exactly one result update with evidence. If a real blocker appears, report it once.`, codeModel)
+        const recovery = await runners.work.runCycle(`The assigned task is NOT complete. Missing runtime evidence: ${missing.join('; ')}. Do not post an acknowledgement or claim success. Resume now. Use get_ticket/list_tasks and list_task_types, perform and verify the repository work, commit and push an agent/* branch, open the PR, and call update_ticket with the correct board column. Post only when the original context supplies a source thread.`, codeModel)
+        const recoveryIncomplete = recovery?.subtype !== 'ok' || !recovery?.didRepoMutation || (ticketCycle && (!recovery?.didMcpTaskRead || !recovery?.didMcpTaskUpdate)) || recovery?.mcpErrors?.length
+        if (recoveryIncomplete) {
+          const taskMatch = /ticket\s+#?(\d+).*?project\s+(\d+)/i.exec(prompt)
+          if (taskMatch) seenTasks.delete(`${taskMatch[2]}:${taskMatch[1]}`)
+          lastTaskSignature = ''
+          log('WORK_CYCLE_FAILED evidence gate still incomplete after one recovery; ticket retained for retry')
+        }
       }
     } finally {
       if (heartbeat) clearInterval(heartbeat)
-      for (const c of targets) { sendStatus(c, 'done'); statusTargets.delete(c) }
+      for (const c of targets) statusTargets.delete(c)
       lane.busy = false
       if (lane.queued || lane.pending.length) { const next = lane.queued || (laneName === 'work' ? 'full' : 'fast'); lane.queued = null; void drain(next) }
     }
@@ -798,33 +823,41 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
     try { writeJson(configPath(slug), { ...(readConfig(slug) || {}), model: codeModel, chatModel: liteModel !== codeModel ? liteModel : '' }, true) } catch { /* best-effort */ }
   }
 
+  const handleTaskSignal = async (kind, raw) => {
+    const hinted = taskFromEvent(raw)
+    const ticketId = hinted && (hinted.id ?? hinted.task_id ?? hinted.taskId)
+    const projectId = hinted && (hinted.project_id ?? hinted.projectId ?? raw.project_id ?? raw.projectId)
+    if (ticketId == null || projectId == null) { log(kind + ' missing ticket/project identity — ignored'); return }
+    try {
+      if (selfAgentId == null) {
+        const agentsData = toolData(await callMcpTool('list_agents'))
+        const self = (Array.isArray(agentsData.agents) ? agentsData.agents : []).find((a) => String(a.identifier || a.slug || '') === identifier)
+        selfAgentId = self?.id != null ? Number(self.id) : null
+      }
+      const ticketData = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
+      const ticket = ticketData.ticket ?? ticketData.task ?? ticketData
+      const assignedId = Number(taskAgentId(ticket) ?? ticket.agent?.id ?? ticket.assigned_agent?.id)
+      const assignedIdentifier = String(ticket.agent?.identifier ?? ticket.assigned_agent?.identifier ?? '')
+      const belongsToSelf = (selfAgentId != null && assignedId === selfAgentId) || assignedIdentifier === identifier
+      const key = `${projectId}:${ticketId}`
+      if (!belongsToSelf) { seenTasks.delete(key); log(kind + ' ticket #' + ticketId + ' is not assigned to this agent — ignored'); return }
+      if (taskIsCompleted(ticket)) { seenTasks.add(key); log(kind + ' ticket #' + ticketId + ' is already complete — ignored'); return }
+      if (seenTasks.has(key)) { log(kind + ' ticket #' + ticketId + ' already queued/active — ignored'); return }
+      seenTasks.add(key); trimSeen(seenTasks)
+      const title = String(ticket.title || hinted.title || '')
+      const taskText = [title, ticket.description, ticket.type, ticket.kind].filter(Boolean).join(' ')
+      const cycleKind = canCode && !coordinationOnly(taskText) ? 'full' : 'coord'
+      log(kind + ' verified ticket #' + ticketId + ' “' + title + '” -> ' + cycleKind + ' lane')
+      void drain(cycleKind, `Authoritative get_ticket verification confirms ticket #${ticketId} in project ${projectId} is open and assigned to YOU: ${JSON.stringify({ id: ticketId, projectId, title, description: ticket.description, priority: ticket.priority, typeId: ticket.type_id ?? ticket.typeId })}. This assignment has no source channel: do not post_message. Use list_task_types and update_ticket to move it active, complete and verify the work, open the PR when applicable, then update/move the ticket with evidence. Never announce it in a channel.`)
+    } catch (e) {
+      log(kind + ' ticket verification failed for #' + ticketId + ': ' + (e?.message || e))
+    }
+  }
+
   function onEvent(k, d) {
     const raw = d && typeof d === 'object' ? d : {}
-    // The backend has NO `task:assigned` event — a task assigned to an agent arrives
-    // as `task:created` (assigned on create) or `task:updated` (assignee changed),
-    // fanned out org-wide. Catch both, keep only agent-assigned tasks, and let the
-    // cycle confirm ownership via get_marching_orders before acting.
-    if (k === 'task:created' || k === 'task:updated') {
-      const envelope = raw.data && typeof raw.data === 'object' ? raw.data : raw
-      const t = envelope.task && typeof envelope.task === 'object' ? envelope.task : envelope
-      const ag = (t.agent && typeof t.agent === 'object') ? t.agent : (t.assigned_agent && typeof t.assigned_agent === 'object') ? t.assigned_agent : null
-      const agentId = t.agent_id ?? t.agentId ?? t.assigned_agent_id ?? t.assignedAgentId ?? t.assignee_agent_id ?? t.assigneeAgentId ?? ag?.id ?? ag?.agent_id ?? null
-      if (agentId == null) return // not assigned to an agent — ignore
-      // If the payload carries the agent's identifier, filter precisely to US and skip
-      // other agents' tasks entirely; otherwise let get_marching_orders confirm.
-      const agIdent = ag && (ag.identifier || ag.slug) ? String(ag.identifier || ag.slug) : null
-      if (agIdent != null && agIdent !== identifier) return
-      const key = `${t.id}:${agentId}`
-      if (t.id != null && seenTasks.has(key)) return
-      if (t.id != null) { seenTasks.add(key); if (seenTasks.size > 500) seenTasks.clear() }
-      log('task ' + k.slice(5) + ' #' + (t.id != null ? t.id : '?') + ' (agent ' + agentId + ') “' + (t.title || '') + '”')
-      const desc = t.description ? ' — ' + String(t.description).replace(/\s+/g, ' ').slice(0, 400) : ''
-      const taskText = [t.title, t.description, t.type, t.kind, Array.isArray(t.labels) ? t.labels.join(' ') : t.labels].filter(Boolean).join(' ')
-      // An assigned task is presumed to require execution. Only explicit board or
-      // messaging work stays on the cheap lane; vague verbs such as "create",
-      // "make", or "improve" must not strand a coding task in coordination.
-      const kind = canCode && !coordinationOnly(taskText) ? 'full' : 'coord'
-      void drain(kind, `A task was just ${k === 'task:created' ? 'created and assigned' : 'assigned'} to an agent in this workspace: task #${t.id != null ? t.id : '?'}: "${t.title || ''}"${desc} (agent_id ${agentId}). Call get_marching_orders to confirm it is assigned to YOU. If it is yours, acknowledge it once, complete it with the tools appropriate to this ${kind === 'full' ? 'coding' : 'coordination'} lane, move the ticket when appropriate, and report the verified result. If it is not yours, do nothing and stop.`)
+    if (k === 'task:assigned' || k === 'task:updated') {
+      void handleTaskSignal(k, 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 : {}
@@ -884,14 +917,7 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
       } else void drain('fast', ctx)
     } else if (k === 'error') {
       const detail = raw && (raw.message || raw.error || raw.reason || raw.code || raw.d?.message || raw.d?.error)
-      // Older backend stages reject agent_status. Stop its heartbeat after the
-      // first immediate rejection instead of producing an error every nine seconds.
-      if (statusEnabled && lastStatusSentAt && Date.now() - lastStatusSentAt < 3000) {
-        statusEnabled = false
-        log('live agent status unsupported by this backend; disabling status heartbeat' + (detail ? ': ' + String(detail).slice(0, 160) : ''))
-      } else {
-        log('error event: ' + (detail ? String(detail) : JSON.stringify(raw)).slice(0, 220))
-      }
+      log('error event: ' + (detail ? String(detail) : JSON.stringify(raw)).slice(0, 220))
     } else {
       log('event ' + k)
     }

package/src/ws.mjs

@@ -101,12 +101,6 @@ export function connectAgentWs({ wsUrl, apiKey, identifier, onEvent, onConnect,
   const api = {
     /** Fire-and-forget send (no-op if the socket isn't open). */
     send(obj) { try { if (ws && ws.readyState === 1) ws.send(JSON.stringify(obj)) } catch { /* closing */ } },
-    /** Show the agent as typing in a channel (docs/WEBSOCKET.md `{type:'typing'}`). */
-    sendTyping(channelId) { api.send({ type: 'typing', channel_id: channelId }) },
-    /** Broadcast a richer live activity state for the agent in a channel — the
-     *  backend fans it out as `agent:status` (see docs/AGENT_STATUS.md). state is
-     *  one of thinking | working | typing | done. */
-    sendStatus(channelId, state, detail) { api.send({ type: 'agent_status', channel_id: channelId, state, ...(detail ? { detail: String(detail).slice(0, 120) } : {}) }) },
     close() {
       closed = true
       clearKeepalive()