openvisio-agent 0.19.9 → 0.19.11

package/README.md

@@ -79,20 +79,21 @@ openvisio-agent watch --name ada --workdir ~/repo  # allow REAL work on a git br
 openvisio-agent stop --name ada                  # stop service + every ada watcher
 ```
 
-The watcher can run up to three assigned coding tasks concurrently. Each ticket gets an isolated model runtime and ticket-specific worktree; tasks sharing the same mutable workspace remain serialized to prevent branch and file conflicts. Chat replies stay serialized, and cancellation targets only the matching ticket or source thread. The work pool reuses local clones and is instructed to preserve dirty/staged work, create unique branches, and stage only task-owned changes. The independent reply lane receives a chat charter and no coding workspace. Codex publishes local branches through the constrained helper, then opens a PR with `gh pr create`; linked-codebase MCP operations are a fallback when the repository cannot be obtained locally.
+The watcher can run up to three assigned coding tasks concurrently. Each ticket gets an isolated model runtime and ticket-specific worktree; tasks sharing the same mutable workspace remain serialized to prevent branch and file conflicts. Replies to one thread stay serialized while up to three independent threads run concurrently, and cancellation targets only the matching ticket or source thread. The work pool reuses local clones and is instructed to preserve dirty/staged work, create unique branches, and stage only task-owned changes. The independent reply lane receives a chat charter and no coding workspace. Codex publishes local branches through the constrained helper, then opens a PR with `gh pr create`; linked-codebase MCP operations are a fallback when the repository cannot be obtained locally.
 
-Publishing a local branch uses an explicit, one-time authorization per repository:
+PR publishing is part of normal coding setup. `connect` authorizes the selected `--workspace` (or `~/openvisio-workspace`) for routine agent-branch pushes and installs the constrained Codex helper rule. New clones and linked worktrees inherit that workspace authority. Existing coding configurations migrate on their next watcher start. Use `--no-pr-push` during setup to opt out.
 
-```bash
-cd /path/to/private-repo
-openvisio-agent authorize-pr-push
-```
+The helper `openvisio-agent push-pr-branch` accepts no arguments. It pushes only HEAD to the matching `agent/*` branch at the verified origin push URL, disables hooks, and rejects protected branches, force pushes, local/file remotes, and credential-bearing URLs. `revoke-pr-push` revokes the repository across its worktrees and survives future starts. `authorize-pr-push --repo <path>` remains available for repositories outside the configured workspace.
+
+Authorization recovery checks paused repositories locally every two seconds and clears both policy and failed-revision state before live ticket verification. It does not need a new watcher or a new chat message. Updating the package still requires the running service to load the new version once.
+
+Fresh top-level messages belong in the agent’s dedicated channel; responses to existing requests stay in their source thread. The watcher resolves a unique exact identity/name match (including `agent-alex` and `alex-agent`) and never falls back to general. Use `connect ... --channel <id>` for a differently named dedicated channel. If it is missing or ambiguous, ticket results remain recorded and channel delivery stays pending; the watcher does not invent a channel-creation tool.
 
-That command installs a narrow Codex rule for `openvisio-agent push-pr-branch` and records the repository's exact root and `origin`. The helper accepts no arguments and can only push `HEAD` to the same `agent/*` branch on that authorized origin. It disables repository hooks and rejects main/master, other branch namespaces, changed remotes, force pushes, local/file remotes, and credential-bearing URLs. Revoke it from the repository with `openvisio-agent revoke-pr-push`.
+Codex and OpenCode use Mastra ACP directly. Work sessions are retained per ticket in a six-entry pool; reply sessions in an eight-entry pool. Idle sessions expire after five minutes and active sessions cannot be evicted. Git snapshots are asynchronous, lightweight commands lazily load the watcher, and logs separate queue wait, preflight, first-event, and total runtime time. Projects reconcile with concurrency three and enqueue tickets before reading optional activity history. Coordination sessions can update the board without gaining repository access.
 
 Assignments use independent FIFO entries with stable-key duplicate suppression and bounded, worktree-aware concurrency. Backlog recovery uses the same ticket verification path as WebSocket events, and each queued ticket is checked again before a model starts. MCP calls have a 20-second deadline including response bodies; tool discovery is cached and paginated. Codex MCP failures retain a bounded, credential-redacted reason in the watcher log. Cancellation targets only its ACP session. Credentials and replay state use atomic file replacement; Mastra persists contextual memory in libSQL.
 
-See `docs/BYO_SYSTEM_AUDIT.md` in the repository for the audit results and remaining live-validation limits. Local certification does not certify a deployed agent's behavior.
+See `docs/BYO_PERFORMANCE_AUDIT_2026-09-08.md` in the repository for the audit results and remaining live-validation limits. Local certification does not certify a deployed agent's behavior.
 
 `--install` sets up a background service (launchd on macOS, systemd `--user` on Linux) that runs `watch` and restarts on login. Logs go to `~/.openvisio/<agent>.log` (macOS) or `journalctl --user -u openvisio-<agent>` (Linux).
 

package/bin/cli.mjs

@@ -13,9 +13,8 @@ import { spawnSync } from 'node:child_process'
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
-import { parseFlags, slugify, stripSlash, exchangeToken, ensureClaude, ensureCodex, writeJson, mcpConfigPath, configPath, chmodSafe, onPath, OV_DIR, fail, ok, info } from '../src/lib.mjs'
-import { runWatch, installService, stopWatchers } from '../src/watch.mjs'
-import { authorizePrPush, pushPrBranch, revokePrPush } from '../src/pr-push.mjs'
+import { parseFlags, slugify, stripSlash, exchangeToken, ensureClaude, ensureCodex, writeJson, mcpConfigPath, configPath, chmodSafe, onPath, OV_DIR, DEFAULT_WORKSPACE, fail, ok, info } from '../src/lib.mjs'
+import { authorizePrPush, pushPrBranch, revokePrPush, configurePrPublishing } from '../src/pr-push.mjs'
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const VERSION = (() => { try { return JSON.parse(readFileSync(join(HERE, '..', 'package.json'), 'utf8')).version } catch { return '0.0.0' } })()
@@ -82,8 +81,13 @@ stop
   remaining watcher with that exact --name and clears its stale lock. Use this
   instead of killing changing PIDs: openvisio-agent stop --name Alex
 
+Use --channel <id> during connect to select the dedicated channel for new threads.
+
+PR publishing is enabled during connect for the coding workspace, including
+  future clones and worktrees. Use --no-pr-push to opt out.
+
 authorize-pr-push
-  One-time, explicit authorization for the current private repository. Installs a
+  Optional authorization outside the configured workspace for the current private repository. Installs a
   narrow Codex command rule and records the exact repository root + origin. The
   permitted helper can only push the current agent/* branch and cannot force-push,
   choose another remote/ref, push a protected branch, or merge.
@@ -168,7 +172,8 @@ async function runConnect({ positional, flags }) {
     ensureOpencode() // the watcher writes opencode.json with the remote MCP at runtime
   }
   const wsWorkdir = flags.workdir === true ? process.cwd() : flags.workdir ? String(flags.workdir) : flags.workspace ? String(flags.workspace) : ''
-  writeJson(configPath(slug), { host: stripSlash(host), key, mcpUrl, name, slug, ...(mcpCfg ? { mcpConfig: mcpCfg } : {}), ...(agent !== 'claude' ? { agent } : {}), ...(wsWorkdir ? { workspace: wsWorkdir } : {}), ...(flags['chat-only'] ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
+  if (!flags['chat-only']) configurePrPublishing({ workspace: wsWorkdir || DEFAULT_WORKSPACE, enabled: !flags['no-pr-push'] })
+  writeJson(configPath(slug), { ...(flags.channel ? { dedicatedChannelId: Number(flags.channel) } : {}), prPublishing: !flags['no-pr-push'], host: stripSlash(host), key, mcpUrl, name, slug, ...(mcpCfg ? { mcpConfig: mcpCfg } : {}), ...(agent !== 'claude' ? { agent } : {}), ...(wsWorkdir ? { workspace: wsWorkdir } : {}), ...(flags['chat-only'] ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
 
   ok(`Connected "${name}" to ${host}.`)
   info()
@@ -247,7 +252,8 @@ async function runConnectBackend({ flags }) {
     }
   }
 
-  writeJson(configPath(slug), { mode: 'backend', backend, apiKey, identifier, name, slug, wsUrl, mcpUrl, mcpConfig, ...(agent !== 'claude' ? { agent } : {}), ...(workdir ? { workspace: workdir } : {}), ...(chatOnly ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
+  if (!chatOnly) configurePrPublishing({ workspace: workdir || DEFAULT_WORKSPACE, enabled: !flags['no-pr-push'] })
+  writeJson(configPath(slug), { ...(flags.channel ? { dedicatedChannelId: Number(flags.channel) } : {}), prPublishing: !flags['no-pr-push'], mode: 'backend', backend, apiKey, identifier, name, slug, wsUrl, mcpUrl, mcpConfig, ...(agent !== 'claude' ? { agent } : {}), ...(workdir ? { workspace: workdir } : {}), ...(chatOnly ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
   // A sourceable env file, matching the setup snippet OpenVisio shows.
   const envPath = join(OV_DIR, `${slug}.env`)
   mkdirSync(OV_DIR, { recursive: true })
@@ -288,6 +294,7 @@ async function runConnectBackend({ flags }) {
   } else {
     info()
     info('Setting up the always-on autonomy listener (auto-starts on login, survives reboot)…')
+    const { installService } = await import('../src/watch.mjs')
     installService({ slug, workdir })
     ok('Your agent is now live — it will catch @mentions and assignments even with no terminal open.')
   }
@@ -302,11 +309,11 @@ async function main() {
   const cmd = argv[0]
   const rest = parseFlags(argv.slice(1))
   if (cmd === 'connect') return runConnect(rest)
-  if (cmd === 'watch') return runWatch(rest)
+  if (cmd === 'watch') return (await import('../src/watch.mjs')).runWatch(rest)
   if (cmd === 'stop') {
     const name = String(rest.flags.name || rest.positional[0] || '')
     if (!name) fail('Missing agent name.\n  Usage: openvisio-agent stop --name <agent>')
-    return stopWatchers({ slug: slugify(name) })
+    return (await import('../src/watch.mjs')).stopWatchers({ slug: slugify(name) })
   }
   if (cmd === 'authorize-pr-push') {
     const cwd = String(rest.flags.repo || rest.positional[0] || process.cwd())

package/package.json

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

package/scripts/certify.mjs

@@ -44,9 +44,14 @@ const quickReply = readFileSync(join(repo, 'frontend', 'app', 'api', 'agent', 'q
 const spec = readFileSync(join(repo, 'docs', 'CODEX_BYO_AGENT_SPEC.md'), 'utf8')
 
 const assertions = [
+  ['setup enables constrained workspace PR publishing', cli.includes('configurePrPublishing({ workspace:') && watcher.includes('configurePrPublishing({ workspace:') && prPush.includes("['rev-parse', '--git-common-dir']")],
+  ['authorization recovery is local and independent of backlog cadence', watcher.includes('resumeReadyAuthorizations(), 2_000') && watcher.includes('releaseAuthorizedPause(key')],
+  ['new follow-ups only deduplicate later replies', watcher.includes('repliesAfterSource(renderedAgentMessages') && watcher.includes('sourceMessageId: mid')],
+  ['Mastra snapshots do not block the event loop', mastraHarness.includes('await execFileAsync') && !mastraHarness.includes('spawnSync')],
+  ['ticket pickup precedes optional activity reads', watcher.indexOf("await handleTaskSignal('task:assigned'", watcher.indexOf('const reconcileBacklog')) < watcher.indexOf("const activityData = await callMcpTool", watcher.indexOf('const reconcileBacklog'))],
   ['task:assigned is handled', watcher.includes("k === 'task:assigned'")],
   ['task signals are verified with get_ticket', watcher.includes("callMcpTool('get_ticket'")],
-  ['review and testing handoffs do not restart work', watcher.includes('taskIsAwaitingReview(task, reviewIds)') && watcher.includes('taskIsAwaitingReview(ticket)')],
+  ['review and testing handoffs do not restart work', watcher.includes('taskIsAwaitingReview(task, reviewIds)') && watcher.includes('taskIsAwaitingReview(ticket, typeSets.review)')],
   ['review handoff releases the task key for future rework', watcher.includes('seenTasks.delete(taskKey)') && watcher.includes('seenTasks.delete(key)')],
   ['assigned coding completion is posted by the watcher', watcher.includes('announceTaskCompletion') && watcher.includes('postMessageOnce({ key: `completion:${report.key}`')],
   ['completion requires review/done state and PR evidence', watcher.includes('buildTaskCompletionReport') && watcher.includes('completion report deferred')],
@@ -66,7 +71,7 @@ const assertions = [
   ['human-facing ticket references require slugs, never database ids', watcher.includes('TICKET SLUGS, NEVER DATABASE IDS') && watcher.includes('ticketDisplaySlug(task)') && events.includes('export function ticketDisplaySlug') && !events.includes('I finished ticket #${task.id}')],
   ['rendered backend replies are checked before every guarded thread post', watcher.includes("callMcpTool('list_message_thread'") && watcher.includes('renderedAgentMessages(live') && watcher.includes('same-content-rendered')],
   ['Codex cannot race the watcher with post_message', watcher.includes("disabledMcpTools: ['post_message']") && codexConfig.includes('disabled_tools = [')],
-  ['Codex cannot continue without OpenVisio MCP tools', watcher.includes('buildCodexMcpOverride') && codexConfig.includes('required = true') && codexConfig.includes('startup_timeout_sec = 30')],
+  ['ACP sessions receive the authenticated OpenVisio proxy', mastraHarness.includes("name: 'openvisio-team-watcher'") && mastraHarness.includes('OPENVISIO_CODEX_MCP_URL') && watcher.includes('missingRuntimeWorkEvidence(result')],
   ['Codex discovers deferred OpenVisio actions before claiming they are missing', watcher.includes('Codex may defer MCP actions') && watcher.includes('use tool_search to find that exact action') && watcher.includes('initial-list miss is NOT evidence that the server is disconnected')],
   ['Codex authentication is injected outside the model', codexConfig.includes('OPENVISIO_CODEX_API_KEY') && codexProxy.includes('toolWithoutCredentialInputs') && codexProxy.includes('client.callTool') && watcher.includes('local OpenVisio MCP bridge injects authentication outside the model')],
   ['reply delivery keys survive reconnects', watcher.includes('deliveredReplies: [...deliveredReplies]') && watcher.includes('deliveredReplies.has(deliveryKey)')],
@@ -76,12 +81,12 @@ const assertions = [
   ['reply runner has no coding workspace or coding charter', watcher.includes("workdir: ''") && watcher.includes("systemPrompt: CHAT_CHARTER + '\\n\\n' + credNote") && opencodeConfig.includes("'*': 'deny'")],
   ['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 warm scoped Mastra ACP sessions', watcher.includes('createMastraAcpRunner') && watcher.includes('const replyRunners = new Map()') && watcher.includes('replyRunnerFor(item.delivery)') && mastraHarness.includes('new AcpAgentClass') && mastraHarness.includes('persistSession: true') && mastraHarness.includes("runtime: 'mastra-acp'")],
+  ['Codex and OpenCode use warm scoped Mastra ACP sessions', watcher.includes('createMastraAcpRunner') && watcher.includes('workRunners.acquire(sessionKey') && watcher.includes('replyRunners.acquire(key') && mastraHarness.includes('persistSession: true')],
   ['runtime models are selected explicitly before work starts', mastraHarness.includes('getAvailableModels()') && mastraHarness.includes('resolveAvailableModel(requestedModel') && mastraHarness.includes('await acp.setModel(resolution.selected)') && modelSelection.includes('automatic model substitution is disabled') && watcher.includes('if (changed) persistModel()')],
-  ['one watcher owns isolated concurrent work and thread-scoped serial reply runtimes', watcher.includes('MAX_CONCURRENT_WORKERS = 3') && watcher.includes('createWorkRunner(item.control, item.workdir)') && watcher.includes('const replyRunners = new Map()') && watcher.includes('while (replyRunners.size > 8)')],
-  ['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)')],
+  ['one watcher owns bounded work and per-thread reply sessions', watcher.includes('MAX_CONCURRENT_WORKERS = 3') && watcher.includes('workRunners.release(sessionKey)') && watcher.includes('replyRunners.release(key)') && watcher.includes('groupKey: (item) => item.taskRef')],
+  ['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(candidate[1].group)')],
   ['work and reply cancellation targets are isolated', watcher.includes('item.control.cancelled = true') && watcher.includes('item.control.runner?.cancelCurrent')],
-  ['assigned task activity resolves a project channel', watcher.includes("callMcpTool('list_channels'") && watcher.includes('projectStatusChannel(projectId)')],
+  ['fresh threads resolve the dedicated agent channel', watcher.includes('dedicatedChannel(Array.isArray(channels)') && watcher.includes('No dedicated agent channel available for a new thread')],
   ['presence notification requests are disabled', watcher.includes('const sendStatus = () => {}') && !watcher.includes('agentStateRequest(') && !watcher.includes("setInterval(() => emitStatusTargets")],
   ['websocket client cannot emit legacy agent_status', !websocket.includes('agent_status')],
   ['frontend consumes thinking event', activityHook.includes("'channel:agent:thinking'")],
@@ -99,15 +104,15 @@ const assertions = [
   ['quick replies preserve distinct top-level conversations', quickReply.includes('m.parentId ?? m.messageId') && quickReply.includes('...(parentId ? { parentId } : {})')],
   ['completion has an evidence failure gate', watcher.includes('WORK_CYCLE_FAILED')],
   ['failed evidence revisions persist and suppress self-triggered retries', watcher.includes('failedTaskVersions: [...failedTaskVersions]') && watcher.includes("failedTaskVersions.set(key, 'pending')") && watcher.includes('failedTaskRevisionIsCurrent(failedRevision, ticket)') && watcher.includes('ticket paused until its revision changes')],
-  ['assigned coding tickets prefer their prepared local worktree', watcher.includes('findTicketWorktree(workdir, ticketId)') && watcher.includes('A prepared local git worktree for this ticket exists') && watcher.includes('Do not call list_codebases, codebase_tree, or get_codebase') && watcher.includes('cwd: cycleCwd') && watcher.includes('workdir: ticketWorktree')],
-  ['OpenCode emits structured events for runtime evidence', watcher.includes("'--format', 'json'") && watcher.includes('opencodeEventEvidence(event)')],
+  ['assigned coding tickets prefer their prepared local worktree', watcher.includes('findTicketWorktree(workdir, ticketId)') && watcher.includes('A prepared local git worktree for this ticket exists') && mastraHarness.includes('cwd: cycleCwd') && watcher.includes('workdir: ticketWorktree')],
+  ['ACP evidence requires completed tools', mastraHarness.includes("if (tool.status !== 'completed') continue") && mastraHarness.includes('codexPolicyBlock(json(tool.rawOutput))')],
   ['OpenCode API-key MCP disables OAuth probing', opencodeConfig.includes("oauth: false") && opencodeConfig.includes('timeout: 15_000')],
-  ['OpenCode identities use isolated configs outside the code workspace', watcher.includes('opencodeRuntimeLayout({ cfgKey, workdir })') && watcher.includes("'--dir', workspace") && watcher.includes('OPENCODE_CONFIG: opencodeConfigPath') && watcher.includes('OPENCODE_CONFIG_CONTENT: JSON.stringify(opencodeConfig)')],
+  ['OpenCode ACP isolates server identity and reply permissions', mastraHarness.includes('OPENCODE_CONFIG_CONTENT') && mastraHarness.includes('buildOpencodeConfig({ canCode })') && mastraHarness.includes('mcpServers,')],
   ['OpenCode backend prompts forbid relay and resource-discovery tools', watcher.includes('BACKEND MCP RULE') && ['get_marching_orders', 'poll_inbox', 'get_resource', 'list_mcp_resources', 'list_mcp_resource_templates'].every((name) => watcher.includes(name))],
-  ['OpenCode tool failures retain sanitized diagnostics', events.includes('toolError: toolError.replace') && watcher.includes("opencode tool '") && watcher.includes("split(redactKey).join('[redacted]')")],
+  ['ACP tool failures retain sanitized diagnostics', mastraHarness.includes('for (const [name, detail] of errors)') && mastraHarness.includes('redact(detail)')],
   ['all runtime acknowledgements cannot satisfy coding completion', watcher.includes('missingRuntimeWorkEvidence(result') && watcher.includes('claudeEventEvidence(o, turnToolUses)') && watcher.includes('releaseTaskForRetry(activeTaskRef, prompt)')],
-  ['Codex prose cannot masquerade as repository evidence', watcher.includes('codexEventEvidence(event)') && events.includes("item.type === 'agent_message'") && events.includes("event.type === 'item.completed'")],
-  ['Codex MCP failures retain sanitized per-call diagnostics', events.includes('rawToolError = item.error') && watcher.includes('mcpErrorDetails.set(evidence.mcpTool, safe)') && watcher.includes("join('[redacted]')")],
+  ['ACP prose cannot masquerade as repository evidence', mastraHarness.includes("if (event.type === 'text') { outputText += event.text; continue }") && mastraHarness.includes("if (tool.status !== 'completed') continue")],
+  ['ACP MCP failures retain sanitized per-call diagnostics', mastraHarness.includes('mcpErrorDetails: Object.fromEntries(errors)') && mastraHarness.includes("join('[redacted]')")],
   ['coding recovery retains source context and requires a final result', watcher.includes('ORIGINAL REQUEST AND ROUTING CONTEXT') && events.includes('resultMessageRequired && !result?.didResultMessage') && events.includes("outputText: second?.outputText || first?.outputText || ''")],
   ['backend MCP accepts stateless initialize responses', mcpHttp.includes("mode = () => !initialized ? 'uninitialized' : sessionId ? 'stateful' : 'stateless'") && !watcher.includes('MCP initialize returned no session id')],
   ['MCP initialize is shared across concurrent startup probes', mcpHttp.includes('if (initializePromise) return initializePromise')],
@@ -115,20 +120,20 @@ const assertions = [
   ['backend MCP tools are discovered and cached', mcpHttp.includes("method: 'tools/list'") && mcpHttp.includes('if (!refresh && toolsCache)') && watcher.includes('discoverMcpTools')],
   ['missing optional MCP tools use compatibility fallbacks', watcher.includes("reason: 'not-advertised'") && watcher.includes('recording the blocker in the ticket description')],
   ['backend introduction is watcher-owned for every runtime', watcher.includes('void announceIntroduction().then((delivered)')],
-  ['Codex policy rejection is captured from stderr', watcher.includes("stdio: ['ignore', 'pipe', 'pipe']") && watcher.includes('forwardDiagnostic(d)') && watcher.includes('inspectDiagnostic(incoming)')],
-  ['Codex recoverable subprocess diagnostics are not surfaced as activity', watcher.includes('shouldSuppressCodexDiagnostic(line)') && watcher.includes("forwardDiagnostic('', true)") && watcher.includes('RECOVER DEAD COMMAND SESSIONS')],
-  ['policy rejection cannot be logged as successful', watcher.includes("subtype = policyBlock ? 'blocked'")],
+  ['ACP helper rejections preserve structured authorization blockers', mastraHarness.includes('codexPolicyBlock(json(tool.rawOutput))') && watcher.includes('reportPolicyBlock(prompt, activeTaskRef, result.policyBlock, delivery)')],
+  ['ACP account notifications stay silent', mastraHarness.includes("property === 'extNotification'") && watcher.includes('RECOVER DEAD COMMAND SESSIONS')],
+  ['policy rejection cannot close a work cycle', mastraHarness.includes("subtype: policyBlock ? 'blocked' : 'ok'") && watcher.includes("result?.subtype === 'blocked'")],
   ['policy-blocked tickets are persisted and paused', watcher.includes('blockedTasks: [...blockedTasks]') && watcher.includes('WORK_CYCLE_BLOCKED')],
   ['repository push authorization automatically resumes the paused ticket', watcher.includes('blockedTaskRepos: [...blockedTaskRepos]') && watcher.includes('repositoryHasPrPushAuthorization')],
   ['BYO coding prefers an existing local repository', watcher.includes('A usable local clone is your primary code surface') && watcher.includes('do not use remote codebase tools') && watcher.includes('Remote codebase tools are a fallback only when the repository cannot be obtained locally')],
   ['Codex publishes local branches with the constrained helper', watcher.includes('CODEX PR DELIVERY') && watcher.includes('openvisio-agent push-pr-branch') && watcher.includes('Use list_codebases/create_codebase_branch/create_codebase_commit/create_pull_request only as a fallback') && events.includes('const codebaseMutation')],
-  ['private PR pushes use an explicit constrained helper', cli.includes("cmd === 'authorize-pr-push'") && cli.includes("cmd === 'push-pr-branch'") && prPush.includes("'push', '-u', 'origin', destination")],
-  ['PR push helper rejects protected/alternate/force targets by construction', prPush.includes("/^agent\\/") && prPush.includes('entry?.root === root && entry?.remote === remote') && prPush.includes('accepts no force, remote, or ref args')],
+  ['private PR pushes use an explicit constrained helper', cli.includes("cmd === 'authorize-pr-push'") && cli.includes("cmd === 'push-pr-branch'") && prPush.includes("'push', '-u', identity.remote, destination")],
+  ['PR push helper restricts branch and destination within setup authority', prPush.includes('isSafeAgentBranch(branch)') && prPush.includes('policyAllows(') && prPush.includes('accepts no force, remote, or ref args')],
   ['Codex recognizes helper authorization as a blocker', events.includes('OPENVISIO_PR_PUSH_AUTH_REQUIRED') && watcher.includes("block?.kind === 'pr-push-authorization-required'")],
   ['policy blocker is surfaced to the user', watcher.includes('reportPolicyBlock(prompt, activeTaskRef, result.policyBlock, delivery)') && watcher.includes("Action required: I'm blocked")],
   ['blocker routing carries explicit task identity', watcher.includes('const activeTaskRef = taskRef') && watcher.includes('taskRef: activeTaskRef')],
   ['reply discovery failures stay scoped while failed mutations fail closed', watcher.includes('blockingReplyMcpErrors(result?.mcpErrors)') && watcher.includes('preserving the scoped model reply') && events.includes('export function blockingReplyMcpErrors')],
-  ['pending-ticket questions use watcher-owned MCP reads without a model cycle', watcher.includes('conversationAsksPendingTickets(text)') && watcher.includes('pending-ticket question -> watcher-owned MCP lookup') && watcher.includes("callMcpReadWithRetry('list_tasks'") && !watcher.includes("callMcpReadWithRetry('list_agents'")],
+  ['pending-ticket questions use watcher-owned MCP reads without a chat model cycle', watcher.includes('conversationAsksPendingTickets(text)') && watcher.includes('pending-ticket question -> watcher-owned MCP lookup') && watcher.includes("callMcpReadWithRetry('list_tasks'") && watcher.includes("if (selfAgentId == null) {\n      const agentsData = toolData(await callMcpReadWithRetry('list_agents'))")],
   ['chat ACP allows opaque MCP approvals behind a strict read-only proxy', mastraHarness.includes('export function acpPermissionResponse') && mastraHarness.includes('opaqueMcpApproval') && mastraHarness.includes('OPENVISIO_CODEX_ALLOWED_TOOLS') && codexProxy.includes('export function toolAllowed') && codexProxy.includes('allowedTools.has(name)')],
   ['all runtime blockers have a delivery path', watcher.includes('publishBlocker') && watcher.includes('WORK_CYCLE_BLOCKED') && watcher.includes('COORDINATION_CYCLE_BLOCKED')],
   ['ticket blocker cannot self-authorize', watcher.includes("ticketNotice = `I'm paused") && watcher.includes('publishBlocker({ prompt, taskRef, delivery, notice, ticketNotice, pause: true })') && !watcher.includes('test(approvalText)')],

package/src/assignment-routing.mjs

@@ -0,0 +1,32 @@
+// Assignment requests are routed by the watcher, before the restricted chat
+// runtime can mistake its own tool limits for the coding worker's capabilities.
+export function assignmentStatusOnly(value) {
+  return /\b(?:do not|don't|dont|stop|cancel|stand down|status only|just (?:list|check|tell|show)|only (?:list|check|tell|show))\b/i.test(String(value || ''))
+}
+
+export function assignmentRequest(value) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim()
+  if (assignmentStatusOnly(text)) return null
+  const slugs = [...new Set((text.match(/\b[a-z][a-z0-9]*-\d+\b/gi) || []).map((slug) => slug.toUpperCase()))]
+  const tickets = /\b(?:tickets?|tasks?|assignments?|backlog)\b/i.test(text) || slugs.length > 0
+  const action = /\b(?:start|begin|resume|continue|implement|fix|finish|complete|handle|execute|dispatch|pick\s+up|work\s+(?:on|through))\b/i.test(text)
+  const assigned = /\b(?:assigned|gave)\s+(?:\S+\s+){0,3}you\b|\byou\s+have\b.*\b(?:pending|assigned)\b/i.test(text)
+  return tickets && (action || assigned) ? { slugs } : null
+}
+
+export async function routeAssignments({ request, loadTickets, handleTask, isCancelled = () => false }) {
+  const tickets = await loadTickets()
+  const selected = tickets.filter((ticket) => !request.slugs.length || request.slugs.includes(ticket.slug))
+  // A project-scoped slug must resolve uniquely before any work is started.
+  for (const slug of request.slugs) {
+    if (selected.filter((ticket) => ticket.slug === slug).length !== 1) {
+      throw new Error(`I couldn't uniquely resolve ${slug} among my open assignments.`)
+    }
+  }
+  const actionable = selected.filter((ticket) => !ticket.awaitingReview)
+  for (const ticket of actionable) {
+    if (isCancelled()) return
+    await handleTask('task:assigned', { task: { id: ticket.id, project_id: ticket.projectId } })
+  }
+  return actionable.length
+}

package/src/authorization-resume.mjs

@@ -0,0 +1,10 @@
+// Authorization recovery takes precedence over the generic failed-revision
+// gate. Clearing only the policy block left tickets permanently stuck.
+export function releaseAuthorizedPause(key, { blocked, repos, failed, seen, authorized }) {
+  if (!blocked.has(key) || !repos.has(key) || !authorized(repos.get(key))) return false
+  blocked.delete(key)
+  repos.delete(key)
+  failed.delete(key)
+  seen.delete(key)
+  return true
+}

package/src/channel-routing.mjs

@@ -0,0 +1,26 @@
+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
+
+export function repliesAfterSource(messages, sourceMessageId) {
+  if (sourceMessageId == null) return messages
+  // 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))
+}
+
+export function dedicatedChannel(channels, { id, identifier, aliases = [], channelId } = {}) {
+  const usable = channels.filter((channel) => validId(channel?.id))
+  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))
+  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)))
+  return matches.length === 1 ? matches[0] : null
+}

package/src/codex-mcp-proxy.mjs

@@ -72,7 +72,9 @@ export function runCodexMcpProxy() {
         let result
         try { result = await client.callTool(name, request.params?.arguments || {}) }
         catch (error) {
-          if (!(allowedTools instanceof Set) || !allowedTools.has(name)) throw error
+          // An allowlisted coordination mutation still must never be replayed
+          // after an ambiguous timeout. Retry only idempotent reads.
+          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)

package/src/concurrency.mjs

@@ -0,0 +1,12 @@
+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
+  await Promise.all(Array.from({ length: Math.min(items.length, concurrency) }, async () => {
+    while (next < items.length) {
+      const index = next++
+      results[index] = await run(items[index], index)
+    }
+  }))
+  return results
+}

package/src/cycle-queue.mjs

@@ -11,7 +11,11 @@ export function createCycleQueue({ run, onError = () => {}, concurrency = 1, gro
 
   const pump = () => {
     while (active.size < concurrency && pending.size) {
-      const available = [...pending].find(([, entry]) => !entry.group || !activeGroups.has(entry.group))
+      // Stop at the first runnable entry without copying the entire backlog.
+      let available
+      for (const candidate of pending) {
+        if (!candidate[1].group || !activeGroups.has(candidate[1].group)) { available = candidate; break }
+      }
       if (!available) return
       const [key, entry] = available
       pending.delete(key)

package/src/mastra-harness.mjs

@@ -1,21 +1,25 @@
-import { spawnSync } from 'node:child_process'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
 import { fileURLToPath } from 'node:url'
 import { AcpAgent } from '@mastra/acp'
 import { onPath } from './lib.mjs'
 import { resolveAvailableModel } from './model-selection.mjs'
+import { codexPolicyBlock } from './events.mjs'
+import { buildOpencodeConfig } from './opencode-config.mjs'
 
 const MCP_TOOL_NAMES = [
   'list_agents', 'list_projects', 'list_tasks', 'list_task_types', 'get_ticket',
   'update_ticket', 'list_channels', 'list_message_thread', 'list_activity',
   'post_message', 'react_message', 'list_codebases', 'get_codebase',
   'codebase_tree', 'create_codebase_branch', 'create_codebase_commit',
-  'create_pull_request',
+  'create_pull_request', 'write_codebase_file', 'comment_ticket',
 ]
 const CHAT_SAFE_MCP_READS = new Set([
   'list_agents', 'list_projects', 'list_tasks', 'list_task_types', 'get_ticket',
   'list_channels', 'list_message_thread', 'list_activity', 'list_codebases',
   'get_codebase', 'codebase_tree',
 ])
+const COORDINATION_TOOLS = ['update_ticket', 'post_message', 'react_message', 'comment_ticket']
 
 const clean = (value, max = 300) => String(value ?? '').replace(/\s+/g, ' ').trim().slice(0, max)
 const json = (value) => { try { return JSON.stringify(value) } catch { return String(value ?? '') } }
@@ -31,27 +35,36 @@ function commandFor(agent) {
 
 const proxyPath = fileURLToPath(new URL('./codex-mcp-proxy.mjs', import.meta.url))
 
-function repositorySnapshot(cwd) {
+const execFileAsync = promisify(execFile)
+async function repositorySnapshot(cwd) {
   if (!cwd) return ''
-  const result = spawnSync('git', ['status', '--porcelain=v1', '--untracked-files=all'], {
-    cwd, encoding: 'utf8', timeout: 10_000,
-  })
-  return result.status === 0 ? String(result.stdout || '') : ''
+  try {
+    const result = await execFileAsync('git', ['status', '--porcelain=v1', '--untracked-files=normal'], { cwd, encoding: 'utf8', timeout: 3_000 })
+    return String(result.stdout || '')
+  } catch { return null }
 }
 
 function toolName(update) {
-  const haystack = `${update?.title || ''} ${json(update?.rawInput)}`
-  return MCP_TOOL_NAMES.find((name) => new RegExp(`(?:^|[^a-z0-9_])${name}(?:$|[^a-z0-9_])`, 'i').test(haystack)) || ''
+  // Inspect names, never arbitrary argument strings: a shell search for
+  // "update_ticket" is not a successful ticket update.
+  const candidates = [update?.title, update?.rawInput?.tool, update?.rawInput?.toolName].filter((value) => typeof value === 'string')
+  for (const candidate of candidates) {
+    const value = candidate.toLowerCase().trim()
+    for (const name of MCP_TOOL_NAMES) {
+      if (value === name || (/^(?:mcp|openvisio)[\w .:/-]*?/.test(value) && new RegExp(`[_ .:/]${name}$`).test(value))) return name
+    }
+  }
+  return ''
 }
 
-export function acpPermissionResponse(request, { canCode = false } = {}) {
+export function acpPermissionResponse(request, { canCode = false, canCoordinate = false, proxyProtected = true } = {}) {
   const options = Array.isArray(request?.options) ? request.options : []
   const name = toolName(request?.toolCall || {})
   const opaqueMcpApproval = request?._meta?.is_mcp_tool_approval === true
   // Codex omits the tool name from correlated ACP permission requests. Chat
   // sessions expose only CHAT_SAFE_MCP_READS through their private proxy, so
   // accepting an opaque MCP approval cannot grant a mutation or local access.
-  const allow = canCode || CHAT_SAFE_MCP_READS.has(name) || opaqueMcpApproval
+  const allow = canCode || CHAT_SAFE_MCP_READS.has(name) || (canCoordinate && COORDINATION_TOOLS.includes(name)) || (opaqueMcpApproval && proxyProtected)
   const preferred = allow ? 'allow_once' : 'reject_once'
   const selected = options.find((option) => option.kind === preferred) || options.find((option) => option.kind.startsWith(allow ? 'allow' : 'reject'))
   return selected ? { outcome: { outcome: 'selected', optionId: selected.optionId } } : { outcome: { outcome: 'cancelled' } }
@@ -65,7 +78,7 @@ function contentText(content) {
 }
 
 export function createMastraAcpRunner({
-  agent, mcpUrl, mcpHeaders = {}, workdir, canCode = !!workdir, maxCycleMs,
+  agent, mcpUrl, mcpHeaders = {}, workdir, canCode = !!workdir, canCoordinate = false, maxCycleMs,
   log = () => {}, debug = false, model, onTool, systemPrompt = '', AcpAgentClass = AcpAgent,
 }) {
   const runtime = commandFor(agent)
@@ -82,10 +95,14 @@ export function createMastraAcpRunner({
     const cycleCwd = cycleOptions.workdir || defaultCwd
     const controller = new AbortController()
     let timedOut = false
-    const before = repositorySnapshot(canCode ? cycleCwd : '')
+    const startedAt = performance.now()
+    const before = canCode ? repositorySnapshot(cycleCwd) : Promise.resolve(null)
+    let firstEventMs = null
+    let policyBlock = null
     const calls = new Set()
     const errors = new Map()
     const tools = new Map()
+    let toolSequence = 0
     let outputText = ''
     let didCode = false
     let didRepoMutation = false
@@ -97,13 +114,14 @@ export function createMastraAcpRunner({
 
     const headers = Object.entries(mcpHeaders).filter(([, value]) => value != null && value !== '').map(([name, value]) => ({ name, value: String(value) }))
     const disabledMcpTools = Array.isArray(cycleOptions.disabledMcpTools) ? cycleOptions.disabledMcpTools.filter(Boolean) : []
-    const mcpServers = !mcpUrl ? [] : agent === 'codex' ? [{
+    const proxyProtected = !!mcpHeaders['x-agent-api-key'] && !!mcpHeaders['x-agent-identifier']
+    const mcpServers = !mcpUrl ? [] : proxyProtected ? [{
       name: 'openvisio-team-watcher', command: process.execPath, args: [proxyPath], env: [
         { name: 'OPENVISIO_CODEX_MCP_URL', value: mcpUrl },
         { name: 'OPENVISIO_CODEX_API_KEY', value: String(mcpHeaders['x-agent-api-key'] || '') },
         { name: 'OPENVISIO_CODEX_IDENTIFIER', value: String(mcpHeaders['x-agent-identifier'] || '') },
         { name: 'OPENVISIO_CODEX_DISABLED_TOOLS', value: JSON.stringify(disabledMcpTools) },
-        { name: 'OPENVISIO_CODEX_ALLOWED_TOOLS', value: canCode ? 'null' : JSON.stringify([...CHAT_SAFE_MCP_READS]) },
+        { name: 'OPENVISIO_CODEX_ALLOWED_TOOLS', value: canCode ? 'null' : JSON.stringify([...CHAT_SAFE_MCP_READS, ...(canCoordinate ? COORDINATION_TOOLS : [])]) },
       ],
     }] : [{ type: 'http', name: 'openvisio-team', url: mcpUrl, headers }]
     const sessionKey = JSON.stringify([cycleCwd, disabledMcpTools, mcpServers])
@@ -123,13 +141,20 @@ export function createMastraAcpRunner({
           // silently discards this session's authenticated stdio bridge.
           DISABLE_MCP_CONFIG_FILTERING: 'true',
           CODEX_CONFIG: JSON.stringify({ 'mcp_servers.openvisio-team.enabled': false }),
+        } : agent === 'opencode' ? {
+          // Keep local tools denied in lightweight ACP sessions, including
+          // installations whose ordinary OpenCode config auto-approves tools.
+          OPENCODE_CONFIG_CONTENT: JSON.stringify({
+            ...buildOpencodeConfig({ canCode }),
+            mcp: { 'openvisio-team': { enabled: false } },
+          }),
         } : {},
         session: {
           cwd: cycleCwd,
           mcpServers,
         },
         persistSession: true,
-        onPermissionRequest: async (request) => acpPermissionResponse(request, { canCode }),
+        onPermissionRequest: async (request) => acpPermissionResponse(request, { canCode, canCoordinate, proxyProtected }),
         // codex-acp publishes account-status extension notifications. They are
         // useful to interactive clients but should be silent in a background
         // watcher, and the stock Mastra ACP client intentionally knows only ACP.
@@ -182,6 +207,7 @@ export function createMastraAcpRunner({
       const fullPrompt = systemPrompt && !sessionHasPrompted ? `${systemPrompt}\n\n${prompt}` : prompt
       sessionHasPrompted = true
       for await (const event of acp.connection.promptStream(fullPrompt, controller.signal)) {
+        firstEventMs ??= Math.round(performance.now() - startedAt)
         if (event.type === 'text') { outputText += event.text; continue }
         const update = event.update || {}
         if (update.sessionUpdate === 'agent_message_chunk') {
@@ -190,7 +216,7 @@ export function createMastraAcpRunner({
         }
         if (!['tool_call', 'tool_call_update'].includes(update.sessionUpdate)) continue
         const prior = tools.get(update.toolCallId) || {}
-        const merged = { ...prior, ...update }
+        const merged = { ...prior, ...update, order: ++toolSequence }
         tools.set(update.toolCallId, merged)
         const name = toolName(merged)
         const label = name || clean(merged.title, 100) || 'tool'
@@ -200,24 +226,34 @@ export function createMastraAcpRunner({
           calls.add(name)
           if (merged.status === 'failed') errors.set(name, clean(json(merged.rawOutput) || merged.title))
           else if (merged.status === 'completed') errors.delete(name)
-          didMessage ||= name === 'post_message'
-          didChannelMessage ||= name === 'post_message'
-          didMcpTaskRead ||= ['list_tasks', 'list_task_types', 'get_ticket'].includes(name)
-          didMcpTaskUpdate ||= name === 'update_ticket'
         }
-        const title = clean(merged.title, 200).toLowerCase()
-        const looksLikeMutation = merged.kind === 'edit' || /\b(edit|write|patch|create|delete|commit)\b/.test(title)
-        didCode ||= ['edit', 'execute'].includes(merged.kind) || looksLikeMutation
-        didRepoMutation ||= looksLikeMutation
       }
-      const after = repositorySnapshot(canCode ? cycleCwd : '')
-      if (before !== after) { didCode = true; didRepoMutation = true }
-      didResultMessage = didChannelMessage && didRepoMutation
+      // Only final, completed tool states are evidence. Started/failed edits and
+      // board mutations cannot stand in for completed repository work.
+      for (const tool of [...tools.values()].sort((a, b) => a.order - b.order)) {
+        const name = toolName(tool)
+        if (tool.status === 'failed') policyBlock ||= codexPolicyBlock(json(tool.rawOutput))
+        if (tool.status !== 'completed') continue
+        didMessage ||= name === 'post_message'
+        didChannelMessage ||= name === 'post_message'
+        didResultMessage ||= name === 'post_message' && didRepoMutation
+        didMcpTaskRead ||= ['list_tasks', 'get_ticket'].includes(name)
+        didMcpTaskUpdate ||= name === 'update_ticket'
+        if (!name && canCode) {
+          didCode ||= ['edit', 'execute'].includes(tool.kind)
+          didRepoMutation ||= tool.kind === 'edit'
+        }
+        didRepoMutation ||= ['create_codebase_commit', 'write_codebase_file'].includes(name)
+        didCode ||= ['create_codebase_commit', 'write_codebase_file'].includes(name)
+      }
+      const beforeState = await before
+      const after = canCode ? await repositorySnapshot(cycleCwd) : null
+      if (beforeState != null && after != null && beforeState !== after) { didCode = true; didRepoMutation = true }
       const redact = (value) => Object.values(mcpHeaders).filter(Boolean).reduce((safe, secret) => safe.split(String(secret)).join('[redacted]'), String(value))
       for (const [name, detail] of errors) log(`MCP ${name} failed: ${redact(detail)}`)
       log(`${agent} cycle done via Mastra ACP (${errors.size ? 'tool-errors' : 'ok'})`)
       return {
-        type: 'result', subtype: 'ok', runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),
+        type: 'result', subtype: policyBlock ? 'blocked' : 'ok', policyBlock, timings: { firstEventMs, totalMs: Math.round(performance.now() - startedAt) }, 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,
@@ -243,9 +279,9 @@ export function createMastraAcpRunner({
 
   const cancelCurrent = async () => {
     if (!active) return
-    active.controller.abort()
-    try { await active.acp.connection.cancel() } catch { /* already stopped */ }
-    const acp = active.acp
+    const { acp, controller } = active
+    controller.abort()
+    try { await acp.connection.cancel() } catch { /* already stopped */ }
     acp.connection.disconnect()
     if (persistent === acp) {
       persistent = null