openvisio-agent 0.19.10 → 0.19.12

package/src/watch.mjs

@@ -8,16 +8,19 @@ import { spawn, spawnSync } from 'node:child_process'
 import { closeSync, writeFileSync, mkdirSync, existsSync, openSync, readFileSync, readdirSync, unlinkSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
 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 { agentAddedByName, blockingReplyMcpErrors, buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, codexEventEvidence, codexPolicyBlock, combineRuntimeWorkEvidence, conversationAsksPendingTickets, conversationNeedsCode, failedTaskRevisionIsCurrent, mentionDedupeKeys, missingRuntimeWorkEvidence, normalizeRenderedMessageText, opencodeEventEvidence, renderedAgentMessages, shouldSuppressCodexDiagnostic, taskAgentId, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
+import { agentAddedByName, blockingReplyMcpErrors, buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, combineRuntimeWorkEvidence, conversationAsksPendingTickets, conversationNeedsCode, failedTaskRevisionIsCurrent, mentionDedupeKeys, missingRuntimeWorkEvidence, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
 import { createMastraMemory } from './memory.mjs'
-import { repositoryHasPrPushAuthorization } from './pr-push.mjs'
+import { repositoryHasPrPushAuthorization, configurePrPublishing } from './pr-push.mjs'
 import { createMcpHttpClient } from './mcp-http.mjs'
-import { buildOpencodeConfig, opencodeRuntimeLayout } from './opencode-config.mjs'
-import { buildCodexMcpOverride } from './codex-config.mjs'
 import { createCycleQueue } from './cycle-queue.mjs'
+import { createRunnerPool } from './runner-pool.mjs'
+import { mapConcurrent } from './concurrency.mjs'
+import { releaseAuthorizedPause } from './authorization-resume.mjs'
+import { dedicatedChannel, repliesAfterSource } from './channel-routing.mjs'
+import { createTaskTypeLookup } from './task-types.mjs'
+import { createThreadContextResolver } from './thread-context.mjs'
 import { assignmentRequest, assignmentStatusOnly, routeAssignments } from './assignment-routing.mjs'
 import { modelProcessOptions, stopModelProcess } from './process-lifecycle.mjs'
 import { createMastraAcpRunner } from './mastra-harness.mjs'
@@ -61,6 +64,7 @@ const REPLY_DISCIPLINE = [
   '  • LOOK UP ASSIGNED WORK. If someone says they assigned you a task, asks which task is yours, or asks for its status, check the live board yourself with list_agents + list_projects + list_tasks and then get_ticket as needed. Match assignments to your authenticated agent identity. Do not ask the teammate for a project slug, ticket slug, or numeric id before trying those MCP tools; ask only if the live lookup fails or returns genuinely ambiguous matches.',
   '  • TICKET SLUGS, NEVER DATABASE IDS. In every human-facing channel message, ticket comment, PR description, summary, blocker, and result, reference a ticket by the exact project-scoped slug returned by get_ticket/list_tasks (for example, `OVS-57`). Numeric project_id and ticket_id values are internal MCP arguments only: never write `#57`, `ticket 57`, or expose a database id to teammates. If the backend omits the slug, use the ticket title or say “the ticket”; do not invent a slug.',
   '  • CLOSE CONCERNS. Never leave a concern, direct question, correction, or blocker addressed to you without a clear response. Acknowledge the concern, act if you can, then report the verified result. If blocked, name the blocker and the exact next action or owner in one message.',
+  '  • NEW THREADS BELONG IN YOUR DEDICATED CHANNEL. Reply to an existing request in its original thread. For any fresh top-level thread (results, blockers, or an introduction), use only your own dedicated agent channel, resolved from live list_channels by your exact identity/name. Never open a fresh thread in general, a project channel, or another agent’s channel. If no unique dedicated channel exists, keep results on the ticket and report the missing channel in an existing source thread. Never invent a channel or tool.',
   '  • WRITE PLAINLY. Prefer short sentences, commas, periods, and colons. Avoid em dashes except when reproducing quoted text.',
 ].join('\n')
 
@@ -102,7 +106,7 @@ const CODE_CHARTER = [
   '',
   'WORK ETHIC — how a reliable teammate behaves (this is the difference between useful and ignored):',
   '  1. CLOSE THE LOOP in THIS cycle. Never say "I\'ll do X" and stop. If you commit to something, do it NOW — the human must never have to remind you to circle back. Sending an intent or progress message is not a stop condition: continue using tools and send the verified result or blocker afterward.',
-  '  2. FINISH, then REPORT. Always update/move the ticket with update_ticket. Reply in a supplied human source thread when one exists. For backlog-assigned work, do not call post_message yourself: the watcher publishes one evidence-verified result in the project channel after the PR and ticket handoff are confirmed.',
+  '  2. FINISH, then REPORT. Always update/move the ticket with update_ticket. Reply in a supplied human source thread when one exists. For backlog-assigned work, do not call post_message yourself: the watcher publishes one evidence-verified result in the dedicated agent channel after the PR and ticket handoff are confirmed.',
   '  3. Be honest and specific. Never invent progress. If you are genuinely blocked (missing repo, unclear spec, a failing tool), say exactly what you need in one message — that IS closing the loop.',
   '  4. One final reply per request; answer several nudges together. A single concrete progress update is allowed during longer work, but it must be followed by the final result or blocker in the same cycle.',
   '  5. RECOVER DEAD COMMAND SESSIONS. If write_stdin reports “Unknown process id”, that command session has already exited. Never poll the same process id again. Start a fresh exec_command when more work is required, then continue the task and verify the final state.',
@@ -122,7 +126,7 @@ const CODE_FULL = [
   '  3. CHANGE + VERIFY: Read/Edit/Write the files; run the tests or build if the repo has them.',
   '  4. COMMIT + PUSH YOUR BRANCH: stage only the specific paths or hunks changed for this task; inspect git diff --cached before committing. If unrelated changes are already staged, use an isolated worktree. Commit with a clear message, then publish only your own agent/* branch using the runtime-specific authorized push flow. Never --force, never push to main/master, never merge.',
   '  5. RAISE A PR: gh pr create --fill --base <default-branch> --head agent/<slug> (a clear title + a body summarizing the change and how you verified it). Never gh pr merge.',
-  '  6. CLOSE THE LOOP: move/update the ticket with update_ticket. Use a ticket-comment tool for a blocker or clarification only when that tool actually appears; otherwise keep the blocker in the ticket update and let the watcher deliver the visible channel result. When a source thread is supplied, follow its explicit delivery rule: either post once or return final text for watcher delivery. For backlog-only tickets, do not call post_message yourself; the watcher sends one verified project-channel completion message and deduplicates it across reconnects.',
+  '  6. CLOSE THE LOOP: move/update the ticket with update_ticket. Use a ticket-comment tool for a blocker or clarification only when that tool actually appears; otherwise keep the blocker in the ticket update and let the watcher deliver the visible channel result. When a source thread is supplied, follow its explicit delivery rule: either post once or return final text for watcher delivery. For backlog-only tickets, do not call post_message yourself; the watcher sends one verified dedicated-channel completion message and deduplicates it across reconnects.',
   'Bash is for git / gh / tests / clone ONLY — never to hunt for credentials (they are given to you above).',
 ].join('\n')
 
@@ -140,7 +144,7 @@ const CODE_FAST = [
 // missed — TASKS especially.
 const INTRO = [
   'You have just JOINED this OpenVisio workspace (your first connection). Workspace etiquette: introduce yourself so the team knows you are here and reachable.',
-  'Find the most general channel — call poll_inbox (or list channels) and pick the "general"/main one — then post_message there ONCE: say in first person that you are here, pick up tasks assigned to you, and answer @mentions. Do not state your name; the app already displays it. Keep it to 1-2 warm, professional sentences.',
+  'Find your own dedicated agent channel using list_channels and your exact identity/name, then post_message there ONCE: say in first person that you are here, pick up assigned tasks, and answer @mentions. Never use general or another agent’s channel for a fresh thread. If no unique dedicated channel exists, do not invent one. Do not state your name; the app already displays it. Keep it to 1-2 sentences.',
   'Post it EXACTLY ONCE, then stop. Do NOT do any other work this cycle.',
 ].join('\n')
 const SWEEP = [
@@ -260,6 +264,7 @@ export async function runWatch({ flags }) {
     : flags.workdir ? String(flags.workdir)
     : flags.workspace ? String(flags.workspace) : ''
   const workdir = chatOnly ? '' : (explicitWorkdir || (saved && (saved.workspace || saved.workdir)) || DEFAULT_WORKSPACE)
+  if (workdir) configurePrPublishing({ workspace: workdir, enabled: !flags['no-pr-push'] && saved?.prPublishing !== false })
   if (workdir) { try { mkdirSync(workdir, { recursive: true }) } catch { /* best-effort; spawn will surface a real problem */ } }
 
   // Use a specific Codex ID; configured chat and code tiers remain independent.
@@ -313,303 +318,15 @@ export async function runWatch({ flags }) {
   return loop({ host, key, slug: slug || 'openvisio', claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug: !!flags.debug })
 }
 
-// ── opencode cycle runner ─────────────────────────────────────────────────────
-// opencode (opencode.ai) has no persistent stream-json protocol like Claude Code,
-// so each cycle is a headless `opencode run <prompt> --auto [--model provider/model]`.
-// The openvisio-team MCP is declared in a private per-agent config. The actual
-// code workspace is passed through --dir, so two agents never overwrite each
-// other's MCP identity even when they work in the same repository.
-// `--auto` approves tool use non-interactively.
-// Same { runCycle, canCode } contract as the Claude runner.
-function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, maxCycleMs, log, debug, model, onTool, systemPrompt }) {
-  const { configDir, configPath: opencodeConfigPath, workspace } = opencodeRuntimeLayout({ cfgKey, workdir })
-  const bin = onPath('opencode') || 'opencode'
-  const redactKey = String(mcpHeaders?.['x-agent-api-key'] || '')
-  const opencodeConfig = buildOpencodeConfig({ mcpUrl, mcpHeaders, canCode })
-  let configured = false
-  let cancelActive = null
-  const ensureConfig = () => {
-    if (configured) return
-    configured = true
-    try {
-      mkdirSync(configDir, { recursive: true })
-      mkdirSync(workspace, { recursive: true })
-      if (opencodeConfig) {
-        writeJson(opencodeConfigPath, opencodeConfig, true)
-      } else {
-        log('WARNING: no --mcp-url — opencode has no openvisio-team tools to act with. Re-connect with --mcp-url.')
-      }
-    } catch (e) { log('opencode config write failed: ' + (e && e.message ? e.message : e)) }
-  }
-
-  function runCycle(prompt, cycleModel) {
-    return new Promise((resolve) => {
-      ensureConfig()
-      const m = cycleModel || model
-      // opencode has no system-prompt flag; each run is a fresh process, so fold the
-      // charter/creds into the message (still not re-accumulated across cycles).
-      const full = systemPrompt ? systemPrompt + '\n\n' + prompt : prompt
-      // JSON mode is the evidence boundary. Formatted stdout only tells us that
-      // OpenCode exited; raw events tell us which tools actually completed.
-      const args = ['run', full, '--auto', '--format', 'json', '--dir', workspace, ...(m ? ['--model', m] : [])]
-      let child = null, done = false, didCode = false, didRepoMutation = false, didMessage = false, didChannelMessage = false, didResultMessage = false, didMcpTaskRead = false, didMcpTaskUpdate = false
-      let terminationResult = null
-      let cancel = null
-      let outputText = '', jsonlBuffer = ''
-      const mcpCalls = new Set(), mcpErrors = new Set(), runtimeErrors = new Set()
-      const finish = (o) => {
-        if (done) return
-        done = true
-        if (cancelActive === cancel) cancelActive = null
-        clearTimeout(timer)
-        const calls = [...mcpCalls]
-        log('opencode MCP calls: ' + (calls.length ? calls.join(', ') : 'none') + (mcpErrors.size ? ' (failed: ' + [...mcpErrors].join(', ') + ')' : ''))
-        resolve({ ...o, didCode, didRepoMutation, didMessage, didChannelMessage, didResultMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, mcpErrors: [...mcpErrors], outputText })
-      }
-      const terminate = (subtype) => {
-        terminationResult ||= { type: 'result', subtype }
-        return stopModelProcess(child).then(() => finish(terminationResult))
-      }
-      const inspectLine = (line) => {
-        const value = String(line || '').trim()
-        if (!value) return
-        let event
-        try { event = JSON.parse(value) } catch {
-          if (debug) log('  · unparsed opencode output: ' + value.slice(0, 180))
-          return
-        }
-        const evidence = opencodeEventEvidence(event)
-        if (evidence.outputText) {
-          outputText += ' ' + evidence.outputText
-          if (debug) log('  · ' + evidence.outputText.replace(/\s+/g, ' ').slice(0, 180))
-        }
-        if (evidence.runtimeError) runtimeErrors.add(evidence.runtimeError)
-        if (!evidence.tool) return
-        if (debug) log('  → tool ' + evidence.tool + (evidence.failed ? ' (failed)' : evidence.completed ? ' (completed)' : ''))
-        if (evidence.failed && evidence.toolError) {
-          const safeError = (redactKey ? String(evidence.toolError).split(redactKey).join('[redacted]') : String(evidence.toolError)).replace(/\s+/g, ' ').slice(0, 240)
-          log('  ✗ opencode tool ' + evidence.tool + ': ' + safeError)
-        }
-        try { onTool && onTool(evidence.tool) } catch { /* activity is best-effort */ }
-        if (evidence.mcpTool) {
-          mcpCalls.add(evidence.mcpTool)
-          if (evidence.failed) mcpErrors.add(evidence.mcpTool)
-          else if (evidence.completed) mcpErrors.delete(evidence.mcpTool)
-        }
-        const repositoryWasChanged = didRepoMutation
-        if (evidence.didChannelMessage && repositoryWasChanged) didResultMessage = true
-        didCode ||= !!evidence.didCode
-        didRepoMutation ||= !!evidence.didRepoMutation
-        didMessage ||= !!evidence.didMessage
-        didChannelMessage ||= !!evidence.didChannelMessage
-        didMcpTaskRead ||= !!evidence.didMcpTaskRead
-        didMcpTaskUpdate ||= !!evidence.didMcpTaskUpdate
-      }
-      const timer = setTimeout(() => {
-        log('opencode cycle TIMED OUT after ' + Math.round(maxCycleMs / 1000) + 's — killing')
-        void terminate('timeout')
-      }, maxCycleMs)
-      cancel = () => terminate('canceled')
-      cancelActive = cancel
-      log('running opencode cycle…' + (m ? ' [' + m + ']' : ''))
-      try {
-        child = spawn(bin, args, {
-          ...modelProcessOptions,
-          cwd: configDir,
-          env: {
-            ...process.env,
-            OPENCODE_CONFIG: opencodeConfigPath,
-            // Inline config has higher precedence than a project opencode.json.
-            // This prevents a stale generated workspace file from replacing this
-            // agent's URL or credentials while keeping normal project settings.
-            ...(opencodeConfig ? { OPENCODE_CONFIG_CONTENT: JSON.stringify(opencodeConfig) } : {}),
-          },
-          stdio: ['ignore', 'pipe', 'inherit'],
-        })
-        child.stdout?.on('data', (data) => {
-          jsonlBuffer += String(data)
-          const lines = jsonlBuffer.split('\n')
-          jsonlBuffer = lines.pop() ?? ''
-          for (const line of lines) inspectLine(line)
-        })
-      }
-      catch (e) { log('opencode spawn failed: ' + (e && e.message ? e.message : e) + ' — is opencode installed? (npm i -g opencode-ai, then `opencode auth login`)'); return finish({ type: 'result', subtype: 'spawn-failed' }) }
-      child.on('close', (code) => {
-        inspectLine(jsonlBuffer); jsonlBuffer = ''
-        const subtype = code === 0 && runtimeErrors.size === 0 ? 'ok' : 'error'
-        log('opencode cycle done (' + (subtype === 'ok' ? 'ok' : 'exit ' + code) + ')')
-        finish(terminationResult || { type: 'result', subtype })
-      })
-      child.on('error', (e) => { log('opencode error: ' + (e && e.message ? e.message : e)); finish({ type: 'result', subtype: 'error' }) })
-    })
-  }
-
-  log('opencode runner ready' + (model ? ' [model ' + model + ']' : '') + (canCode ? ' [CODE workspace ' + workspace + '; isolated cfg ' + configDir + ']' : ' [CHAT-ONLY; isolated cfg ' + configDir + ']'))
-  return { runCycle, canCode, cancelCurrent: () => cancelActive?.() }
-}
-
-// Codex has a purpose-built non-interactive mode. Run a fresh, ephemeral cycle
-// for each event and inject only this agent's OpenVisio MCP config on the command
-// 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, onTool, systemPrompt }) {
-  const bin = onPath('codex') || 'codex'
-  const defaultCwd = workdir || OV_DIR
-  const proxyPath = fileURLToPath(new URL('./codex-mcp-proxy.mjs', import.meta.url))
-  let cancelActive = null
-
-  function runCycle(prompt, cycleModel, cycleOptions = {}) {
-    return new Promise((resolve) => {
-      const m = cycleModel || model
-      const cycleCwd = cycleOptions.workdir || defaultCwd
-      const full = systemPrompt ? systemPrompt + '\n\n' + prompt : prompt
-      const disabledMcpTools = Array.isArray(cycleOptions.disabledMcpTools) ? cycleOptions.disabledMcpTools.filter(Boolean) : []
-      const mcpOverride = buildCodexMcpOverride({ mcpUrl, proxyCommand: process.execPath, proxyPath, disabledMcpTools })
-      const args = ['exec', '--ignore-user-config', '--skip-git-repo-check', '--ephemeral', '--json', '--color', 'never',
-        ...(canCode ? ['--approve-for-me'] : ['--sandbox', 'read-only']),
-        ...(m ? ['--model', m] : []),
-        ...(mcpOverride ? ['-c', mcpOverride] : []),
-        full]
-      let child = null, done = false, didCode = false, didRepoMutation = false, didMessage = false, didChannelMessage = false, didResultMessage = false, outputText = '', jsonlBuffer = '', stderrBuffer = '', stderrLineBuffer = ''
-      let terminationResult = null
-      let cancel = null
-      let policyBlock = null
-      const mcpCalls = new Set(), mcpErrors = new Set(), mcpErrorDetails = new Map()
-      let didMcpTaskRead = false, didMcpTaskUpdate = false
-      const finish = (o) => {
-        if (done) return
-        done = true
-        if (cancelActive === cancel) cancelActive = null
-        clearTimeout(timer)
-        const calls = [...mcpCalls]
-        const failedSummary = [...mcpErrors].map((name) => `${name}${mcpErrorDetails.get(name) ? ': ' + mcpErrorDetails.get(name) : ''}`).join('; ')
-        log('codex MCP calls: ' + (calls.length ? calls.join(', ') : 'none') + (failedSummary ? ' (failed: ' + failedSummary + ')' : ''))
-        resolve({ ...o, didCode, didRepoMutation, didMessage, didChannelMessage, didResultMessage, didMcpTaskRead, didMcpTaskUpdate, mcpCalls: calls, mcpErrors: [...mcpErrors], mcpErrorDetails: Object.fromEntries(mcpErrorDetails), outputText, policyBlock })
-      }
-      const terminate = (subtype) => {
-        terminationResult ||= { type: 'result', subtype }
-        return stopModelProcess(child).then(() => finish(terminationResult))
-      }
-      const inspectDiagnostic = (value) => {
-        const s = String(value || '')
-        stderrBuffer = (stderrBuffer + s).slice(-24_000)
-        policyBlock = codexPolicyBlock(stderrBuffer) || policyBlock
-      }
-      const forwardDiagnostic = (value, flush = false) => {
-        const incoming = String(value || '')
-        inspectDiagnostic(incoming)
-        stderrLineBuffer += incoming
-        const lines = stderrLineBuffer.split('\n')
-        stderrLineBuffer = lines.pop() ?? ''
-        for (const line of lines) {
-          if (!shouldSuppressCodexDiagnostic(line)) process.stderr.write(line + '\n')
-        }
-        if (flush && stderrLineBuffer) {
-          if (!shouldSuppressCodexDiagnostic(stderrLineBuffer)) process.stderr.write(stderrLineBuffer)
-          stderrLineBuffer = ''
-        }
-      }
-      const inspectLine = (line) => {
-        const s = line.trim()
-        if (!s) return
-        policyBlock = codexPolicyBlock(s) || policyBlock
-        try {
-          const event = JSON.parse(s)
-          const evidence = codexEventEvidence(event)
-          if (evidence.outputText) outputText += ' ' + evidence.outputText
-          if (evidence.mcpTool) {
-            mcpCalls.add(evidence.mcpTool)
-            try { onTool && onTool(evidence.mcpTool) } catch { /* activity is best-effort */ }
-            if (evidence.failed) {
-              mcpErrors.add(evidence.mcpTool)
-              if (evidence.toolError) {
-                const secret = String(mcpHeaders?.['x-agent-api-key'] || '')
-                const detail = String(evidence.toolError)
-                const safe = (secret ? detail.split(secret).join('[redacted]') : detail).slice(0, 300)
-                mcpErrorDetails.set(evidence.mcpTool, safe)
-              }
-            } else if (evidence.completed) {
-              mcpErrors.delete(evidence.mcpTool)
-              mcpErrorDetails.delete(evidence.mcpTool)
-            }
-          }
-          if (evidence.didChannelMessage && didRepoMutation) didResultMessage = true
-          didCode ||= !!evidence.didCode
-          didRepoMutation ||= !!evidence.didRepoMutation
-          didMessage ||= !!evidence.didMessage
-          didChannelMessage ||= !!evidence.didChannelMessage
-          didMcpTaskRead ||= !!evidence.didMcpTaskRead
-          didMcpTaskUpdate ||= !!evidence.didMcpTaskUpdate
-        } catch { /* non-JSON diagnostic */ }
-        if (debug) log('  · ' + s.slice(0, 220))
-      }
-      const timer = setTimeout(() => {
-        log('codex cycle TIMED OUT after ' + Math.round(maxCycleMs / 1000) + 's — killing')
-        void terminate('timeout')
-      }, maxCycleMs)
-      cancel = () => terminate('canceled')
-      cancelActive = cancel
-      log('running codex cycle…' + (m ? ' [' + m + ']' : ''))
-      try {
-        // Always inspect Codex JSONL so a successful process exit cannot be
-        // mistaken for completed work. Keep it out of normal logs unless debug.
-        child = spawn(bin, args, {
-          ...modelProcessOptions,
-          cwd: cycleCwd,
-          env: {
-            ...process.env,
-            ...(mcpUrl ? {
-              OPENVISIO_CODEX_MCP_URL: mcpUrl,
-              OPENVISIO_CODEX_API_KEY: mcpHeaders?.['x-agent-api-key'] || '',
-              OPENVISIO_CODEX_IDENTIFIER: mcpHeaders?.['x-agent-identifier'] || '',
-            } : {}),
-          },
-          stdio: ['ignore', 'pipe', 'pipe'],
-        })
-        if (child.stdout) child.stdout.on('data', (d) => {
-          jsonlBuffer += String(d)
-          const lines = jsonlBuffer.split('\n')
-          jsonlBuffer = lines.pop() ?? ''
-          for (const line of lines) inspectLine(line)
-        })
-        if (child.stderr) child.stderr.on('data', (d) => {
-          forwardDiagnostic(d)
-        })
-      } catch (e) {
-        log('codex spawn failed: ' + (e && e.message ? e.message : e) + ' — is Codex installed and signed in? (`npm i -g @openai/codex`, then `codex login`)')
-        return finish({ type: 'result', subtype: 'spawn-failed' })
-      }
-      child.on('close', (code) => {
-        inspectLine(jsonlBuffer); jsonlBuffer = ''; forwardDiagnostic('', true)
-        const subtype = policyBlock ? 'blocked' : code === 0 ? 'ok' : 'error'
-        log('codex cycle done (' + (subtype === 'blocked' ? 'BLOCKED: user authorization required' : subtype === 'ok' ? 'ok' : 'exit ' + code) + ')')
-        finish(terminationResult || { type: 'result', subtype })
-      })
-      child.on('error', (e) => { log('codex error: ' + (e && e.message ? e.message : e)); finish({ type: 'result', subtype: 'error' }) })
-    })
-  }
-
-  if (!mcpUrl) log('WARNING: no --mcp-url — Codex has no openvisio-team tools to act with. Re-connect with --mcp-url.')
-  log('codex runner ready' + (model ? ' [model ' + model + ']' : '') + (canCode ? ' [CODE workspace ' + defaultCwd + ']' : ' [CHAT-ONLY]'))
-  return { runCycle, canCode, cancelCurrent: () => cancelActive?.() }
-}
-
-// ── Claude Code warm-session cycle runner (shared by the REST + WS loops) ─────
-// One persistent stream-json session, poked with a prompt per cycle. Recycled
-// after MAX_TURNS or SESSION_IDLE_MS. Returns { runCycle, canCode }.
-function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model, onTool, systemPrompt }) {
+// Claude keeps its native stream; Codex and OpenCode use Mastra ACP.
+function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model, onTool, systemPrompt, canCoordinate = false }) {
   const canCode = !!workdir
   const maxCycleMs = canCode ? MAX_CODE_CYCLE_MS : MAX_CYCLE_MS
   // Codex and OpenCode run through Mastra's ACP harness. Each queue worker gets
   // its own ACP session and worktree, so cancellation, permissions and context
   // cannot bleed across concurrently assigned tickets.
-  const mastraRunner = createMastraAcpRunner({ agent, mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, log, debug, model, onTool, systemPrompt })
+  const mastraRunner = createMastraAcpRunner({ agent, mcpUrl, mcpHeaders, workdir, canCode, canCoordinate, maxCycleMs, log, debug, model, onTool, systemPrompt })
   if (mastraRunner) return mastraRunner
-  // 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, onTool, 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
@@ -779,7 +496,7 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
     child = null
     return stopModelProcess(active).then(() => settleTurn({ type: 'result', subtype: 'canceled' }))
   }
-  return { runCycle, canCode, cancelCurrent }
+  return { runCycle, canCode, cancelCurrent, close: () => { void cancelCurrent() } }
 }
 
 // ── the backend WS loop ──────────────────────────────────────────────────────
@@ -799,12 +516,12 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   const canCode = !!workdir
   // The Mastra bridge authenticates per-CALL: every openvisio-team tool needs
   // agent_identifier + agent_api_key as arguments. Hand them over up front.
-  const authRule = agent === 'codex'
+  const authRule = agent !== 'claude'
     ? 'AUTH: the local OpenVisio MCP bridge injects authentication outside the model. Never add, request, print, or search for agent credentials in tool arguments.'
     : `AUTH: the openvisio-team tools REQUIRE two arguments on EVERY call — agent_identifier: "${identifier}" and agent_api_key: "${apiKey}". Include BOTH on every openvisio-team tool call. The credentials are given here; do NOT hunt for them.`
   const credNote = `${authRule} Codex may defer MCP actions instead of placing them in the initial tool list. If a native tool_search is available and an expected openvisio-team action is not initially visible, use tool_search to find that exact action, then call it; an initial-list miss is NOT evidence that the server is disconnected. Do not ask a teammate to reconnect or provide a slug until tool_search and the applicable live lookup have actually failed. On backend MCP, discover and update work with list_agents, list_projects, list_tasks, list_task_types, get_ticket, update_ticket, list_channels, list_message_thread, and list_activity as applicable. Ticket comments are optional: never invent or call comment_ticket unless that exact tool appears or tool_search finds it. get_marching_orders, poll_inbox, get_resource, list_mcp_resources, and list_mcp_resource_templates are NOT team-action tools here; never call them. Tools may be namespaced — call whichever names actually appear. Bash/git/gh ARE for code work; this rule only forbids searching for keys.`
-  // The STATIC charter + creds are the session system prompt (cached, billed once),
-  // NOT re-sent in every cycle's user message — the big token saving.
+  // Keep the static charter stable so provider prompt caching can reuse it.
+  // Actual cache hits and billing depend on the runtime and model provider.
   const systemPrompt = (canCode ? CODE_CHARTER : CHAT_CHARTER) + '\n\n' + credNote
   const runnerOptions = {
     claude, agent, mcpUrl, mcpHeaders: { 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier },
@@ -820,30 +537,21 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     ...(workerWorkdir ? { workdir: workerWorkdir } : {}),
     onTool: (name) => { if (/post_message/.test(name)) emitStatusTargets(control.statusTargets, 'typing') },
   })
-  const replyRunners = new Map()
-  const replyRunnerFor = (delivery) => {
-    const key = delivery ? `${delivery.channelId ?? '?'}:${delivery.parentId ?? 'root'}` : 'global'
-    let runner = replyRunners.get(key)
-    if (!runner) {
-      runner = createCycleRunner({
-        ...runnerOptions,
-        workdir: '',
-        systemPrompt: CHAT_CHARTER + '\n\n' + credNote,
-        cfgKey: identifier + '-reply-' + slugify(key),
-        onTool: (name) => { if (/post_message/.test(name)) emitStatusTargets(replyStatusTargets, 'typing') },
-      })
-    } else replyRunners.delete(key)
-    replyRunners.set(key, runner)
-    while (replyRunners.size > 8) {
-      const oldestKey = replyRunners.keys().next().value
-      const oldest = replyRunners.get(oldestKey)
-      replyRunners.delete(oldestKey)
-      oldest?.close?.()
-    }
-    return runner
-  }
+  const workRunners = createRunnerPool({
+    create: ({ control, workdir }) => createWorkRunner(control, workdir),
+    capacity: 6,
+  })
+  const activeReplyRunners = new Set()
+  const replyRunners = createRunnerPool({
+    capacity: 8,
+    create: ({ key, canCoordinate }) => createCycleRunner({
+      ...runnerOptions, workdir: '', canCoordinate,
+      systemPrompt: CHAT_CHARTER + '\n\n' + credNote,
+      cfgKey: identifier + '-reply-' + slugify(key),
+    }),
+  })
   const codexPushGuide = agent === 'codex' && canCode
-    ? '\n\nCODEX PR DELIVERY: when the repository exists in the local workspace, use that clone for branch creation, edits, tests, and commits; do not inspect or mutate it through linked-codebase MCP tools. To publish the local agent/* branch, run `openvisio-agent push-pr-branch` from the repository, then open the PR with `gh pr create`. The helper can only push HEAD to the matching agent/* branch on the exact authorized origin. If it reports OPENVISIO_PR_PUSH_AUTH_REQUIRED, do not retry or route around it. Report the one-time command `openvisio-agent authorize-pr-push` as the blocker. Use list_codebases/create_codebase_branch/create_codebase_commit/create_pull_request only as a fallback when the repository cannot be obtained locally.'
+    ? '\n\nCODEX PR DELIVERY: when the repository exists in the local workspace, use that clone for branch creation, edits, tests, and commits; do not inspect or mutate it through linked-codebase MCP tools. To publish the local agent/* branch, run `openvisio-agent push-pr-branch` from the repository, then open the PR with `gh pr create`. The helper can only push HEAD to the matching agent/* branch on the exact authorized origin. If it reports OPENVISIO_PR_PUSH_AUTH_REQUIRED, do not retry or route around it. PR publishing is enabled during connection setup for the coding workspace and its worktrees. If authorization is missing outside that workspace, report the exact repository configuration issue once; never tell the user to restart the watcher. Use list_codebases/create_codebase_branch/create_codebase_commit/create_pull_request only as a fallback when the repository cannot be obtained locally.'
     : ''
   const backendToolRule = 'BACKEND MCP RULE: the event and watcher already provide the work source. Never call get_marching_orders, poll_inbox, get_resource, list_mcp_resources, or list_mcp_resource_templates; they are not backend team actions. Codex can defer MCP actions: native tool_search is allowed and must be used to find an expected openvisio-team action that is absent from the initial list. An initial-list miss does not mean the MCP server is unavailable. For live discovery use list_agents, list_projects, list_tasks, list_task_types, list_activity, get_ticket, and list_channels as applicable. Never call comment_ticket unless that exact optional tool is present or tool_search finds it.'
   const fullPrompt = (canCode ? CODE_FULL + codexPushGuide : 'Handle the supplied verified backend ticket with the available OpenVisio tools. Update or comment on the ticket as requested, do not claim repository work in chat-only mode, and stop after the verified action.') + '\n\n' + backendToolRule
@@ -861,11 +569,12 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       concurrency: MAX_CONCURRENT_WORKERS,
       groupKey: (item) => item.workdir || workdir || 'shared-workspace',
       run: async (item) => {
-        const runner = createWorkRunner(item.control, item.workdir)
+        const sessionKey = JSON.stringify([item.taskRef ? `ticket:${item.taskRef.projectId}:${item.taskRef.ticketId}` : `thread:${item.delivery?.channelId}:${item.delivery?.parentId}`, item.workdir || workdir])
+        const runner = workRunners.acquire(sessionKey, { control: item.control, workdir: item.workdir })
         item.control.runner = runner
         activeWorkRunners.add(runner)
         try { return await executeCycle(item.kind, item.context, item.targetChannels, item.taskRef, item.delivery, runner, item.control, item.workdir) }
-        finally { runner.close?.(); activeWorkRunners.delete(runner); item.control.runner = null }
+        finally { workRunners.release(sessionKey); activeWorkRunners.delete(runner); item.control.runner = null }
       },
       onError: (error, item) => {
         pauseFailedTask(item.taskRef)
@@ -874,11 +583,15 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       },
     }),
     reply: createCycleQueue({
+      concurrency: 3,
+      groupKey: (item) => item.taskRef ? `ticket:${item.taskRef.projectId}:${item.taskRef.ticketId}` : `thread:${item.delivery?.channelId}:${item.delivery?.parentId}`,
       run: async (item) => {
-        const runner = replyRunnerFor(item.delivery)
+        const key = JSON.stringify([item.taskRef ? `ticket:${item.taskRef.projectId}:${item.taskRef.ticketId}` : `thread:${item.delivery?.channelId}:${item.delivery?.parentId}`, item.kind === 'coord'])
+        const runner = replyRunners.acquire(key, { key, canCoordinate: item.kind === 'coord' })
+        activeReplyRunners.add(runner)
         item.control.runner = runner
         try { return await executeCycle(item.kind, item.context, item.targetChannels, item.taskRef, item.delivery, runner, item.control, '') }
-        finally { item.control.runner = null }
+        finally { replyRunners.release(key); activeReplyRunners.delete(runner); item.control.runner = null }
       },
       onError: (error, item) => {
         pauseFailedTask(item.taskRef)
@@ -958,7 +671,6 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     trimMap(failedTaskVersions)
     seenTasks.add(key)
     trimSeen(seenTasks)
-    lastTaskSignature = ''
     persistReplay()
   }
   const finalizeFailedTaskPause = async (taskRef) => {
@@ -990,6 +702,14 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     persistReplay()
     return false
   }
+  const resumeAuthorized = (key) => {
+    const resumed = releaseAuthorizedPause(key, {
+      blocked: blockedTasks, repos: blockedTaskRepos, failed: failedTaskVersions, seen: seenTasks,
+      authorized: (cwd) => repositoryHasPrPushAuthorization({ cwd }),
+    })
+    if (resumed) { persistReplay(); log('PR authorization ready; resuming ' + key) }
+    return resumed
+  }
   const markMentionHandled = (message, channelId) => {
     pruneMentionSignatures()
     const { idKey, signatureKey } = mentionDedupeKeys(message, channelId)
@@ -1005,8 +725,6 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   // hoping poll_inbox re-surfaces the same item. Each queue entry retains that
   // source independently through work, recovery, and delivery.
   let backlogProbeBusy = false
-  let lastTaskSignature = ''
-  let lastTaskTriggeredAt = 0
   let lastInboxSignature = ''
   let selfAgentId = null
   let completionRecipientName = ''
@@ -1067,6 +785,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     try { return JSON.parse(text) } catch { return { text } }
   }
 
+  const taskTypeSets = createTaskTypeLookup({ load: (projectId) => callMcpTool('list_task_types', { project_id: projectId }).then(toolData) })
+
   const callMcpReadWithRetry = async (name, args = {}) => {
     try { return await callMcpTool(name, args) }
     catch (first) {
@@ -1084,19 +804,13 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     }
     const projectsData = toolData(await callMcpReadWithRetry('list_projects'))
     const projects = Array.isArray(projectsData.projects) ? projectsData.projects : []
-    const groups = await Promise.all(projects.filter((project) => project?.id != null).map(async (project) => {
+    const groups = await mapConcurrent(projects.filter((project) => project?.id != null), 3, async (project) => {
       const [tasksResult, typesResult] = await Promise.all([
         callMcpReadWithRetry('list_tasks', { project_id: project.id }),
-        callMcpReadWithRetry('list_task_types', { project_id: project.id }).catch((error) => {
-          log(`list_task_types read unavailable for project ${project.id}: ${error?.message || error}`)
-          return null
-        }),
+        taskTypeSets(project.id),
       ])
       const tasksData = toolData(tasksResult)
-      const typesData = typesResult ? toolData(typesResult) : {}
-      const types = Array.isArray(typesData.types) ? typesData.types : Array.isArray(typesData.task_types) ? typesData.task_types : Array.isArray(typesData.taskTypes) ? typesData.taskTypes : []
-      const doneIds = new Set(types.filter((type) => /\b(?:done|complete|completed|closed|cancelled|canceled|archived|resolved)\b/i.test(String(type.name || ''))).map((type) => Number(type.id)))
-      const reviewIds = new Set(types.filter((type) => /\b(?:review|test|testing|qa|quality\s+assurance|verification|approval)\b/i.test(String(type.name || ''))).map((type) => Number(type.id)))
+      const { done: doneIds, review: reviewIds } = typesResult
       return (Array.isArray(tasksData.tasks) ? tasksData.tasks : []).filter((task) => {
         const assignedId = Number(taskAgentId(task) ?? task.agent?.id ?? task.assigned_agent?.id)
         const assignedIdentifier = String(task.agent?.identifier ?? task.agent?.slug ?? task.assigned_agent?.identifier ?? task.assigned_agent?.slug ?? '')
@@ -1111,7 +825,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         state: String(task.type?.name ?? task.task_type?.name ?? task.status ?? '').trim(),
         project: String(project.name || ''),
       }))
-    }))
+    })
     return groups.flat()
   }
 
@@ -1163,8 +877,32 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const controlKey = threadControlKey(channelId, parentId)
     if (controlKey) memory.remember({ key: controlKey, kind: 'thread', state: 'active', summary, refs: { channelId: Number(channelId), threadId: parentId } })
   }
-  const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', allowCancelled = false }) => {
+  const saveOwnThread = (channelId, rootId, content) => {
+    memory.remember({ key: `own-root:${channelId}:${rootId}`, kind: 'thread', state: 'authored', summary: content, refs: { channelId: Number(channelId), threadId: rootId }, meta: { rootContent: content } })
+    if (!memory.has(threadControlKey(channelId, rootId), 'cancelled')) activateThread(channelId, rootId, content)
+  }
+  const resolveOwnThread = createThreadContextResolver({
+    read: (cid, root) => {
+      const cached = memory.get(`own-root:${cid}:${root}`)?.meta?.rootContent
+      if (cached) return cached
+      // Previous releases recorded the posted message id but not ownership.
+      // This also recovers roots when the thread API returns only replies.
+      const previous = memory.recall({ channelId: cid }, 1000).find((node) => node.kind === 'delivery' && node.state === 'rendered' && node.refs?.threadId == null && String(node.meta?.messageId) === String(root))
+      if (previous?.summary) saveOwnThread(cid, root, previous.summary)
+      return previous?.summary || ''
+    },
+    save: saveOwnThread,
+    cancelled: (cid, root) => memory.has(threadControlKey(cid, root), 'cancelled'),
+    identity: () => ({ id: selfAgentId, identifier, slug, name: slug }),
+    load: async (cid, root) => toolData(await callMcpTool('list_message_thread', { channel_id: Number(cid), message_id: Number(root) })),
+  })
+  const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', sourceMessageId, allowCancelled = false }) => {
     const deliveryKey = String(key || '')
+    if (parentId == null) {
+      channelId = await projectStatusChannel(projectId)
+      if (channelId == null) throw new Error('No dedicated agent channel available for a new thread')
+      projectId = undefined // dedicated channels may be organization-scoped
+    }
     const message = String(content || '').trim()
     if (!deliveryKey || !Number.isFinite(Number(channelId)) || !message) return { posted: false, reason: 'invalid-delivery' }
     if (deliveredReplies.has(deliveryKey) || memory.has(deliveryKey, 'rendered')) return { posted: false, reason: 'remembered' }
@@ -1182,7 +920,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const run = (async () => {
       if (parentId != null) {
         const live = toolData(await callMcpTool('list_message_thread', { channel_id: Number(channelId), message_id: Number(parentId) }))
-        const rendered = renderedAgentMessages(live, { id: selfAgentId, identifier, slug, name: slug })
+        const rendered = repliesAfterSource(renderedAgentMessages(live, { id: selfAgentId, identifier, slug, name: slug }), sourceMessageId)
         const duplicate = rendered.some((row) => normalizeRenderedMessageText(row.content) === normalizeRenderedMessageText(message))
         if (duplicate || (skipIfAnyAgentReply && rendered.length)) {
           deliveredReplies.add(deliveryKey); trimSeen(deliveredReplies); persistReplay()
@@ -1205,6 +943,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         ...(parentId != null ? { parent_id: Number(parentId) } : {}),
         content: message,
       }))
+      const postedId = result.id ?? result.message?.id ?? result.message_id
+      if (parentId == null && postedId != null) saveOwnThread(channelId, postedId, message)
       deliveredReplies.add(deliveryKey); trimSeen(deliveredReplies); persistReplay()
       memory.remember({ key: deliveryKey, kind: 'delivery', state: 'rendered', summary: message, refs: { channelId: Number(channelId), ...(parentId != null ? { threadId: Number(parentId) } : {}), ...(Number.isFinite(Number(projectId)) ? { projectId: Number(projectId) } : {}) }, meta: { messageId: result.id ?? result.message?.id ?? null } })
       if (sourceKey) memory.connect(deliveryKey, sourceKey, 'responds_to')
@@ -1215,24 +955,30 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   }
 
   const statusChannelCache = new Map()
+  let dedicatedChannelRead = null
   const projectStatusChannel = async (projectId) => {
-    const key = Number(projectId)
-    const cached = statusChannelCache.get(key)
+    const cached = statusChannelCache.get('self')
     if (cached && cached.expiresAt > Date.now()) return cached.channelId
-    try {
-      const data = toolData(await callMcpTool('list_channels', { project_id: key }))
-      const channels = Array.isArray(data.channels) ? data.channels : Array.isArray(data.data?.channels) ? data.data.channels : Array.isArray(data.data) ? data.data : Array.isArray(data.items) ? data.items : []
-      const usable = channels.filter((c) => Number.isFinite(Number(c.id)))
-      const preferred = usable.find((c) => /^(?:general|team|project|dev|development)$/i.test(String(c.name || '').trim())) || usable[0]
-      const channelId = preferred ? Number(preferred.id) : null
-      statusChannelCache.set(key, { channelId, expiresAt: Date.now() + 5 * 60_000 })
-      if (channelId == null) log('no channel available for project ' + key + '; task activity cannot be displayed')
-      return channelId
-    } catch (e) {
-      statusChannelCache.set(key, { channelId: null, expiresAt: Date.now() + 30_000 })
-      log('cannot resolve activity channel for project ' + key + ': ' + (e?.message || e))
-      return null
-    }
+    if (dedicatedChannelRead) return dedicatedChannelRead
+    dedicatedChannelRead = (async () => {
+      try {
+        if (selfAgentId == null) {
+          const agents = toolData(await callMcpTool('list_agents')).agents || []
+          rememberSelfAgent(agents.find((entry) => String(entry.identifier || entry.slug || '') === identifier))
+        }
+        const data = toolData(await callMcpTool('list_channels'))
+        const channels = data.channels ?? data.data?.channels ?? data.data ?? data.items ?? []
+        const channel = dedicatedChannel(Array.isArray(channels) ? channels : [], { id: selfAgentId, identifier, aliases: [...selfAliases], channelId: readConfig(slug)?.dedicatedChannelId })
+        const channelId = channel ? Number(channel.id) : null
+        statusChannelCache.set('self', { channelId, expiresAt: Date.now() + (channelId ? 300_000 : 10_000) })
+        if (channelId == null) log('No unique dedicated agent channel; top-level delivery stays pending.')
+        return channelId
+      } catch (error) {
+        log('Dedicated channel lookup failed: ' + (error?.message || error))
+        return null
+      }
+    })().finally(() => { dedicatedChannelRead = null })
+    return dedicatedChannelRead
   }
 
   const announceIntroduction = async () => {
@@ -1241,7 +987,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const project = projects.find((item) => Number.isFinite(Number(item.id)))
     if (!project) { log('no project available for first-connection introduction'); return false }
     const channelId = await projectStatusChannel(project.id)
-    if (!Number.isFinite(Number(channelId))) return false
+    if (channelId == null || !Number.isFinite(Number(channelId))) return false
     await postMessageOnce({
       key: `intro:${identifier}:${project.id}`,
       projectId: Number(project.id),
@@ -1276,9 +1022,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       try {
         const comment = await callOptionalMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: report.content })
         if (comment.called) log('posted verified ticket comment for #' + ticketId)
-        else log('comment_ticket is not exposed; completing ticket #' + ticketId + ' through its verified state and project-channel report')
+        else log('comment_ticket is not exposed; completing ticket #' + ticketId + ' through its verified state and dedicated-channel report')
       } catch (e) {
-        log('optional ticket comment failed for #' + ticketId + ': ' + (e?.message || e) + '; continuing with the verified project-channel report')
+        log('optional ticket comment failed for #' + ticketId + ': ' + (e?.message || e) + '; continuing with the verified dedicated-channel report')
       }
       reportedTaskComments.add(report.key); trimSeen(reportedTaskComments); persistReplay()
     }
@@ -1296,8 +1042,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       log('completion for ticket #' + ticketId + ' was already posted by the work cycle')
       return true
     }
-    const channelId = Number.isFinite(Number(taskRef.channelId)) ? Number(taskRef.channelId) : await projectStatusChannel(projectId)
-    if (!Number.isFinite(channelId)) return false
+    const channelId = await projectStatusChannel(projectId)
+    if (channelId == null || !Number.isFinite(channelId)) return false
     await postMessageOnce({ key: `completion:${report.key}`, projectId, channelId, content: report.content, sourceKey: memoryKey })
     reportedCompletions.add(report.key); trimSeen(reportedCompletions)
     pendingCompletionReports.delete(taskKey); persistReplay()
@@ -1379,7 +1125,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       ? `Reply with: “I explicitly authorize you to push commit ${block.commit} to the exact repository URL for ${block.remote || 'the configured remote'}, on branch ${block.branch}.”`
       : 'Explicitly authorize the exact repository URL, commit, and branch in your reply.'
     const notice = `Action required: I'm blocked at \`${command}\`${payload ? ` (${payload})` : ''}. Codex requires confirmation before exporting private repository code. ${approval} I've paused the ticket until that approval is recorded.`
-    const ticketNotice = `I'm paused at \`${command}\`${payload ? ` (${payload})` : ''}. Repository push confirmation is required in the project channel; I won't retry automatically.`
+    const ticketNotice = `I'm paused at \`${command}\`${payload ? ` (${payload})` : ''}. Repository push confirmation is required in the dedicated agent channel; I won't retry automatically.`
     return publishBlocker({ prompt, taskRef, delivery, notice, ticketNotice, pause: true })
   }
 
@@ -1396,122 +1142,103 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       rememberSelfAgent(self)
       const projectsData = toolData(await callMcpTool('list_projects'))
       const projects = Array.isArray(projectsData.projects) ? projectsData.projects : []
-      const assigned = []
       const mentionActivity = []
       let activityReplayTouched = false
-      for (const project of projects) {
-        const [tasksData, typesData, activityData] = await Promise.all([
-          callMcpTool('list_tasks', { project_id: project.id }).then(toolData),
-          callMcpTool('list_task_types', { project_id: project.id }).then(toolData),
-          // Chat history is optional for assignment pickup. An unavailable
-          // activity feed must not strand otherwise verified pending tickets.
-          callMcpTool('list_activity', { project_id: project.id }).then(toolData).catch((error) => {
-            log('activity reconciliation unavailable: ' + (error?.message || error))
-            return {}
-          }),
-        ])
-        const taskTypes = Array.isArray(typesData.types) ? typesData.types : Array.isArray(typesData.task_types) ? typesData.task_types : Array.isArray(typesData.taskTypes) ? typesData.taskTypes : []
-        const doneIds = new Set(taskTypes.filter((t) => /\b(?:done|complete|completed|closed|cancelled|canceled|archived|resolved)\b/i.test(String(t.name || ''))).map((t) => Number(t.id)))
-        const reviewIds = new Set(taskTypes.filter((t) => /\b(?:review|test|testing|qa|quality\s+assurance|verification|approval)\b/i.test(String(t.name || ''))).map((t) => Number(t.id)))
-        for (const task of Array.isArray(tasksData.tasks) ? tasksData.tasks : []) {
-          const taskAgentId = Number(task.agent_id ?? task.agentId ?? task.agent?.id)
-          const taskIdent = String(task.agent?.identifier ?? task.agent?.slug ?? '')
-          if (taskAgentId !== Number(self.id) && taskIdent !== identifier) continue
-          const taskKey = `${project.id}:${task.id}`
-          if (taskIsCompleted(task, doneIds) || taskIsAwaitingReview(task, reviewIds)) {
-            memory.remember({ key: `ticket:${project.id}:${task.id}`, kind: 'ticket', state: 'handoff', summary: task.title, refs: { projectId: project.id, ticketId: task.id } })
-            if (pendingCompletionReports.has(taskKey)) {
-              const activityChannel = await projectStatusChannel(project.id)
-              try { await announceTaskCompletion({ projectId: project.id, ticketId: task.id, channelId: activityChannel }) }
-              catch (e) { log('completion report retry failed for ticket #' + task.id + ': ' + (e?.message || e)) }
+      await mapConcurrent(projects, 3, async (project) => {
+        try {
+          const assigned = []
+          const [tasksData, typesData] = await Promise.all([
+            callMcpTool('list_tasks', { project_id: project.id }).then(toolData),
+            taskTypeSets(project.id),
+          ])
+          const { done: doneIds, review: reviewIds } = typesData
+          for (const task of Array.isArray(tasksData.tasks) ? tasksData.tasks : []) {
+            const taskAgentId = Number(task.agent_id ?? task.agentId ?? task.agent?.id)
+            const taskIdent = String(task.agent?.identifier ?? task.agent?.slug ?? '')
+            if (taskAgentId !== Number(self.id) && taskIdent !== identifier) continue
+            const taskKey = `${project.id}:${task.id}`
+            if (taskIsCompleted(task, doneIds) || taskIsAwaitingReview(task, reviewIds)) {
+              memory.remember({ key: `ticket:${project.id}:${task.id}`, kind: 'ticket', state: 'handoff', summary: task.title, refs: { projectId: project.id, ticketId: task.id } })
+              if (pendingCompletionReports.has(taskKey)) {
+                const activityChannel = await projectStatusChannel(project.id)
+                try { await announceTaskCompletion({ projectId: project.id, ticketId: task.id, channelId: activityChannel }) }
+                catch (e) { log('completion report retry failed for ticket #' + task.id + ': ' + (e?.message || e)) }
+              }
+              if (blockedTasks.delete(taskKey)) { blockedTaskRepos.delete(taskKey); persistReplay() }
+              clearFailedTask(taskKey)
+              // Release the in-flight de-dupe key at handoff. If a reviewer moves
+              // the ticket back to an actionable column, that update must start a
+              // fresh work cycle.
+              seenTasks.delete(taskKey)
+              continue
             }
-            if (blockedTasks.delete(taskKey)) { blockedTaskRepos.delete(taskKey); persistReplay() }
-            clearFailedTask(taskKey)
-            // Release the in-flight de-dupe key at handoff. If a reviewer moves
-            // the ticket back to an actionable column, that update must start a
-            // fresh work cycle.
-            seenTasks.delete(taskKey)
-            continue
-          }
-          if (failedTaskIsPaused(taskKey, task)) {
-            seenTasks.add(taskKey)
-            log('backlog ticket #' + task.id + ' is paused at its failed revision; waiting for a ticket change')
-            continue
-          }
-          if (blockedTasks.has(taskKey)) {
-            const blockedRepo = blockedTaskRepos.get(taskKey)
-            const helperAuthorized = blockedRepo && repositoryHasPrPushAuthorization({ cwd: blockedRepo })
-            if (helperAuthorized) {
-              blockedTasks.delete(taskKey); blockedTaskRepos.delete(taskKey); seenTasks.delete(taskKey); persistReplay()
-              log('backlog ticket #' + task.id + (helperAuthorized ? ' has repository-scoped PR push authorization' : ' now contains explicit push authorization') + ' — resuming')
-            } else continue
-          }
-          memory.remember({ key: `ticket:${project.id}:${task.id}`, kind: 'ticket', state: 'assigned', summary: task.title, refs: { projectId: project.id, ticketId: task.id }, meta: { updatedAt: task.updated_at ?? task.updatedAt } })
-          assigned.push({ id: task.id, slug: ticketDisplaySlug(task), 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 : []
-        const mentionNeedles = [self.name, self.identifier, self.slug, identifier].filter(Boolean).map((s) => '@' + String(s).toLowerCase())
-        for (const item of activities) {
-          const text = JSON.stringify(item)
-          const activityKey = String(project.id) + ':' + String(item.id ?? item.message_id ?? item.messageId ?? text.slice(0, 500))
-          const data = item?.data && typeof item.data === 'object' ? item.data : null
-          const activityMessage = item?.message && typeof item.message === 'object'
-            ? item.message
-            : data?.message && typeof data.message === 'object' ? data.message : item
-          const activityText = String(activityMessage?.content ?? activityMessage?.body ?? activityMessage?.text ?? '').toLowerCase()
-          const activityChannelId = item?.channel_id ?? item?.channelId ?? data?.channel_id ?? data?.channelId
-          const activityMessageId = activityMessage?.id ?? activityMessage?.message_id ?? activityMessage?.messageId
-          const activityParentId = activityMessage?.parent_id ?? activityMessage?.parentId
-          const activityThreadRoot = activityParentId != null ? activityParentId : activityMessageId
-          const activityControlKey = threadControlKey(activityChannelId, activityThreadRoot)
-          const ownedActivity = !!activityControlKey && memory.has(activityControlKey, 'active')
-          // Search only the source message, never the whole activity envelope: an
-          // old tagged thread root can otherwise make another agent's new reply
-          // look addressed to this watcher. Explicit mentions and human follow-ups
-          // in a persistently owned thread both enter the guarded per-message path.
-          const addressedActivity = mentionNeedles.some((needle) => activityText.includes(needle)) || ownedActivity
-          if (!seenActivities.has(activityKey) && addressedActivity && /message|mention|channel/i.test(text)) {
-            seenActivities.add(activityKey); trimSeen(seenActivities); activityReplayTouched = true
-            // The same logical mention may already have arrived over WebSocket.
-            // Share the id/signature guard instead of starting a second model turn.
-            // Recover the former pre-routing acknowledgement bug exactly once
-            // when an owned-thread source has no received ledger entry.
-            if (markMentionHandled(activityMessage, activityChannelId)) {
-              const activityMentionKeys = mentionDedupeKeys(activityMessage, activityChannelId)
-              const activitySourceKey = `mention:${activityChannelId ?? '?'}:${activityMentionKeys.idKey || activityMentionKeys.signatureKey || activityThreadRoot}`
-              if (!ownedActivity || memory.has(activitySourceKey, 'received')) continue
+            resumeAuthorized(taskKey)
+            if (failedTaskIsPaused(taskKey, task)) {
+              seenTasks.add(taskKey)
+              log('backlog ticket #' + task.id + ' is paused at its failed revision; waiting for a ticket change')
+              continue
             }
-            mentionActivity.push({
-              projectId: project.id,
-              project: project.name,
-              channelId: activityChannelId,
-              message: activityMessage,
-              activity: item,
-            })
+            if (blockedTasks.has(taskKey)) continue
+            memory.remember({ key: `ticket:${project.id}:${task.id}`, kind: 'ticket', state: 'assigned', summary: task.title, refs: { projectId: project.id, ticketId: task.id }, meta: { updatedAt: task.updated_at ?? task.updatedAt } })
+            assigned.push({ id: task.id, slug: ticketDisplaySlug(task), projectId: project.id, project: project.name, title: task.title, priority: task.priority, typeId: task.type_id ?? task.typeId, updatedAt: task.updated_at ?? task.updatedAt })
           }
-        }
-      }
-      if (activityReplayTouched) persistReplay()
-      if (!assigned.length) lastTaskSignature = ''
-      else {
-        const signature = JSON.stringify(assigned)
-        const retryDue = Date.now() - lastTaskTriggeredAt > 30 * 60 * 1000
-        if (signature !== lastTaskSignature || retryDue) {
-          lastTaskSignature = signature
-          lastTaskTriggeredAt = Date.now()
           const priorityRank = { critical: 0, high: 1, medium: 2, low: 3 }
-          const candidates = [...assigned].sort((a, b) => (priorityRank[String(a.priority).toLowerCase()] ?? 9) - (priorityRank[String(b.priority).toLowerCase()] ?? 9) || String(a.updatedAt || '').localeCompare(String(b.updatedAt || '')))
-          log('backlog reconciliation found ' + assigned.length + ' assigned task(s); verifying independent queue entries')
-          for (const next of candidates) {
+          assigned.sort((a, b) => (priorityRank[a.priority] ?? 9) - (priorityRank[b.priority] ?? 9) || String(a.updatedAt || '').localeCompare(String(b.updatedAt || '')))
+          for (const next of assigned) {
             const key = `${next.projectId}:${next.id}`
             if (queues.work.has(`ticket:${key}`) || queues.reply.has(`ticket:${key}`)) continue
-            if (retryDue) seenTasks.delete(key)
-            // Share verification, ownership, dedupe, and chat-only routing with
-            // live events. Every ticket keeps its own context and result.
+            // Live ownership/state verification remains inside handleTaskSignal.
+            seenTasks.delete(key)
             await handleTaskSignal('task:assigned', { task: { id: next.id, project_id: next.projectId } })
           }
-        }
-      }
+          const activityData = await callMcpTool('list_activity', { project_id: project.id }).then(toolData).catch((error) => {
+            log('activity reconciliation unavailable: ' + (error?.message || error))
+            return {}
+          })
+          const activities = Array.isArray(activityData.activities) ? activityData.activities : Array.isArray(activityData.activity) ? activityData.activity : []
+          const mentionNeedles = [self.name, self.identifier, self.slug, identifier].filter(Boolean).map((s) => '@' + String(s).toLowerCase())
+          for (const item of activities) {
+            const text = JSON.stringify(item)
+            const activityKey = String(project.id) + ':' + String(item.id ?? item.message_id ?? item.messageId ?? text.slice(0, 500))
+            const data = item?.data && typeof item.data === 'object' ? item.data : null
+            const activityMessage = item?.message && typeof item.message === 'object'
+              ? item.message
+              : data?.message && typeof data.message === 'object' ? data.message : item
+            const activityText = String(activityMessage?.content ?? activityMessage?.body ?? activityMessage?.text ?? '').toLowerCase()
+            const activityChannelId = item?.channel_id ?? item?.channelId ?? data?.channel_id ?? data?.channelId
+            const activityMessageId = activityMessage?.id ?? activityMessage?.message_id ?? activityMessage?.messageId
+            const activityParentId = activityMessage?.parent_id ?? activityMessage?.parentId
+            const activityThreadRoot = activityParentId != null ? activityParentId : activityMessageId
+            const activityControlKey = threadControlKey(activityChannelId, activityThreadRoot)
+            const ownedActivity = !!activityControlKey && memory.has(activityControlKey, 'active')
+            // Search only the source message, never the whole activity envelope: an
+            // old tagged thread root can otherwise make another agent's new reply
+            // look addressed to this watcher. Explicit mentions and human follow-ups
+            // in a persistently owned thread both enter the guarded per-message path.
+            const addressedActivity = mentionNeedles.some((needle) => activityText.includes(needle)) || ownedActivity || activityParentId != null
+            if (!seenActivities.has(activityKey) && addressedActivity && /message|mention|channel/i.test(text)) {
+              seenActivities.add(activityKey); trimSeen(seenActivities); activityReplayTouched = true
+              // The same logical mention may already have arrived over WebSocket.
+              // Share the id/signature guard instead of starting a second model turn.
+              // Recover the former pre-routing acknowledgement bug exactly once
+              // when an owned-thread source has no received ledger entry.
+              if (markMentionHandled(activityMessage, activityChannelId)) {
+                const activityMentionKeys = mentionDedupeKeys(activityMessage, activityChannelId)
+                const activitySourceKey = `mention:${activityChannelId ?? '?'}:${activityMentionKeys.idKey || activityMentionKeys.signatureKey || activityThreadRoot}`
+                if (memory.has(activitySourceKey, 'received')) continue
+              }
+              mentionActivity.push({
+                projectId: project.id,
+                project: project.name,
+                channelId: activityChannelId,
+                message: activityMessage,
+                activity: item,
+              })
+            }
+          }
+        } catch (error) { log('Project reconciliation failed: ' + (error?.message || error)) }
+      })
+      if (activityReplayTouched) persistReplay()
       const inboxSignature = JSON.stringify(mentionActivity.slice(-20)).slice(0, 4000)
       if (mentionActivity.length && inboxSignature !== lastInboxSignature) {
         lastInboxSignature = inboxSignature
@@ -1549,20 +1276,21 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     }
     // The next task update or periodic reconciliation must be allowed to queue
     // this work again. An acknowledgement is not a terminal task signature.
-    lastTaskSignature = ''
   }
 
   function drain(kind, context, targetChannels = [], taskRef = null, delivery = null) {
     const laneName = kind === 'full' ? 'work' : 'reply'
     const key = taskRef ? `ticket:${taskRef.projectId}:${taskRef.ticketId}` : delivery?.key
     const itemWorkdir = laneName === 'work' && taskRef ? findTicketWorktree(workdir, taskRef.ticketId) : ''
-    const control = { cancelled: false, runner: null, statusTargets: new Set() }
+    const control = { cancelled: false, runner: null, statusTargets: new Set(), enqueuedAt: performance.now() }
     return queues[laneName].enqueue({ kind, context, targetChannels, taskRef, delivery, workdir: itemWorkdir, control }, key)
   }
 
   async function executeCycle(kind, context, targetChannels = [], taskRef = null, delivery = null, runner, control, preparedWorkdir = '') {
     const laneName = kind === 'full' ? 'work' : 'reply'
     const cycleControl = control || { cancelled: false, runner, statusTargets: new Set() }
+    const cycleStartedAt = performance.now()
+    log(`cycle timing queue=${Math.round(cycleStartedAt - (cycleControl.enqueuedAt ?? cycleStartedAt))}ms kind=${kind}`)
     const ctx = context ? [context] : []
     const activeTaskRef = taskRef
     const ticketWorktree = preparedWorkdir || (kind === 'full' && activeTaskRef ? findTicketWorktree(workdir, activeTaskRef.ticketId) : '')
@@ -1595,18 +1323,21 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       if (activeTaskRef) {
         const data = toolData(await callMcpTool('get_ticket', { project_id: activeTaskRef.projectId, ticket_id: activeTaskRef.ticketId }))
         const ticket = data.ticket ?? data.task ?? data
+        const typeSets = await taskTypeSets(activeTaskRef.projectId)
         const assignedId = Number(taskAgentId(ticket) ?? ticket.agent?.id ?? ticket.assigned_agent?.id)
         const assignedIdentifier = String(ticket.agent?.identifier ?? ticket.assigned_agent?.identifier ?? '')
         if (blockedTasks.has(`${activeTaskRef.projectId}:${activeTaskRef.ticketId}`) ||
             !((selfAgentId != null && assignedId === selfAgentId) || assignedIdentifier === identifier) ||
-            taskIsCompleted(ticket) || taskIsAwaitingReview(ticket)) {
+            taskIsCompleted(ticket, typeSets.done) || taskIsAwaitingReview(ticket, typeSets.review)) {
           releaseTaskForRetry(activeTaskRef, prompt)
           log('queued ticket no longer actionable; skipped before model start')
           return
         }
       }
       if (cycleControl.cancelled) return
+      log(`cycle timing preflight=${Math.round(performance.now() - cycleStartedAt)}ms kind=${kind}`)
       const result = await runner.runCycle(prompt, useModel, runnerOptions)
+      if (result?.timings) log(`cycle timing runtime=${JSON.stringify(result.timings)} kind=${kind}`)
       if (result?.model && result.model !== useModel) {
         // Persist only a successfully selected model and only if the user has
         // not changed that tier while this cycle was running.
@@ -1755,6 +1486,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       }
       const ticketData = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
       const ticket = ticketData.ticket ?? ticketData.task ?? ticketData
+      const typeSets = await taskTypeSets(projectId)
       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
@@ -1769,7 +1501,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         memory.remember({ key: `ticket:${projectId}:${ticketId}`, kind: 'ticket', state: 'unassigned', summary: ticket.title, refs: { projectId, ticketId } })
         blockedTasks.delete(key); blockedTaskRepos.delete(key); pendingCompletionReports.delete(key); failedTaskVersions.delete(key); persistReplay(); seenTasks.delete(key); log(kind + ' ticket #' + ticketId + ' is not assigned to this agent — ignored'); return
       }
-      if (taskIsCompleted(ticket) || taskIsAwaitingReview(ticket)) {
+      if (taskIsCompleted(ticket, typeSets.done) || taskIsAwaitingReview(ticket, typeSets.review)) {
         memory.remember({ key: `ticket:${projectId}:${ticketId}`, kind: 'ticket', state: 'handoff', summary: ticket.title, refs: { projectId, ticketId } })
         if (pendingCompletionReports.has(key)) {
           const activityChannel = await projectStatusChannel(projectId)
@@ -1780,6 +1512,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         log(kind + ' ticket #' + ticketId + ' is already complete or awaiting review — ignored')
         return
       }
+      resumeAuthorized(key)
       const hadFailedRevision = failedTaskVersions.has(key)
       if (failedTaskIsPaused(key, ticket)) {
         seenTasks.add(key)
@@ -1787,17 +1520,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         return
       }
       if (hadFailedRevision) log(kind + ' ticket #' + ticketId + ' changed since its failed cycle — resuming once')
-      if (blockedTasks.has(key)) {
-        const blockedRepo = blockedTaskRepos.get(key)
-        const helperAuthorized = blockedRepo && repositoryHasPrPushAuthorization({ cwd: blockedRepo })
-        if (helperAuthorized) {
-          blockedTasks.delete(key); blockedTaskRepos.delete(key); seenTasks.delete(key); persistReplay()
-          log(kind + ' ticket #' + ticketId + (helperAuthorized ? ' has repository-scoped PR push authorization' : ' contains explicit push authorization') + ' — resuming')
-        } else {
-          log(kind + ' ticket #' + ticketId + ' is paused for explicit repository push authorization — ignored')
-          return
-        }
-      }
+      if (blockedTasks.has(key)) { log(kind + ' ticket authorization is still unavailable'); 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 || '')
@@ -1812,13 +1535,33 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       if (cycleKind === 'full') { pendingCompletionReports.add(key); trimSeen(pendingCompletionReports); persistReplay() }
       const humanTicketRef = ticketSlug ? `ticket ${ticketSlug}` : `the ticket “${title}”`
       const workspaceDirective = preparedWorktree ? ` A prepared local git worktree for this ticket exists at ${JSON.stringify(preparedWorktree)}. Start repository inspection and edits there. Do not call list_codebases, codebase_tree, or get_codebase while this local worktree is available.` : ''
-      void drain(cycleKind, `Authoritative get_ticket verification confirms ${humanTicketRef} is open and assigned to YOU. Internal tool identity: project_id ${projectId}, ticket_id ${ticketId}. For every get_ticket call pass exactly { project_id: ${projectId}, ticket_id: ${ticketId} }; for list_task_types pass exactly { project_id: ${projectId} }. Numeric ids are MCP arguments only and must never appear in human-facing text; use ${ticketSlug || 'the ticket title'} instead. Ticket details: ${JSON.stringify({ slug: ticketSlug, title, description: ticket.description, priority: ticket.priority, typeId: ticket.type_id ?? ticket.typeId })}.${workspaceDirective} This assignment has no source thread: do not call post_message yourself. 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. For coding work, the watcher will publish exactly one verified completion result in the project channel.`, activityChannel == null ? [] : [activityChannel], { projectId, ticketId, channelId: activityChannel })
+      void drain(cycleKind, `Authoritative get_ticket verification confirms ${humanTicketRef} is open and assigned to YOU. Internal tool identity: project_id ${projectId}, ticket_id ${ticketId}. For every get_ticket call pass exactly { project_id: ${projectId}, ticket_id: ${ticketId} }; for list_task_types pass exactly { project_id: ${projectId} }. Numeric ids are MCP arguments only and must never appear in human-facing text; use ${ticketSlug || 'the ticket title'} instead. Ticket details: ${JSON.stringify({ slug: ticketSlug, title, description: ticket.description, priority: ticket.priority, typeId: ticket.type_id ?? ticket.typeId })}.${workspaceDirective} This assignment has no source thread: do not call post_message yourself. 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. For coding work, the watcher will publish exactly one verified completion result in the dedicated agent channel.`, activityChannel == null ? [] : [activityChannel], { projectId, ticketId, channelId: activityChannel })
     } catch (e) {
       log(kind + ' ticket verification failed for #' + ticketId + ': ' + (e?.message || e))
     }
   }
 
+  const mentionIntake = new Map()
   function onEvent(k, d) {
+    if (k !== 'agent:mention') return routeEvent(k, d)
+    const cid = d?.channel_id ?? d?.channelId
+    const message = d?.message || {}
+    const parent = message.parent_id ?? message.parentId
+    const key = `${cid}:${parent ?? message.id ?? message.message_id}`
+    // Keep redirects ordered while a legacy root is being verified. Other
+    // conversations can resolve and run independently.
+    const next = (mentionIntake.get(key) || Promise.resolve()).then(async () => {
+      const preliminary = classifyConversationTarget(message, [...selfAliases])
+      const irrelevant = preliminary.action === 'ignore' && preliminary.reason !== 'unaddressed-thread-activity'
+      const rootContent = parent == null || irrelevant || preliminary.action === 'stand_down' ? '' : await resolveOwnThread(cid, parent)
+      routeEvent(k, { ...d, _threadRootContent: rootContent })
+    }).catch((error) => log('mention thread verification failed: ' + (error?.message || error)))
+      .finally(() => { if (mentionIntake.get(key) === next) mentionIntake.delete(key) })
+    mentionIntake.set(key, next)
+    return next
+  }
+
+  function routeEvent(k, d) {
     const raw = d && typeof d === 'object' ? d : {}
     if (k === 'task:assigned' || k === 'task:updated') {
       void handleTaskSignal(k, raw)
@@ -1872,7 +1615,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       // redirect can cancel its process. Codex additionally delegates the final
       // post to the watcher for an authoritative last-moment thread check.
       const conversationDelivery = (stage = 'reply', skipIfAnyAgentReply = stage !== 'result') => cid != null
-        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, watcherOwned: agent === 'codex' }
+        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, sourceMessageId: mid, watcherOwned: agent === 'codex' }
         : null
       // Under-the-hood model control from chat (view / switch the model the agent runs).
       const mcmd = cid != null ? parseModelCmd(text) : null
@@ -1928,13 +1671,14 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       // Light up the live status the instant we pick this up; drain owns the
       // subsequent working/typing heartbeat for its lane.
       if (cid != null) sendStatus(cid, 'thinking')
-      const codingMention = canCode && conversationNeedsCode(text)
+      const codingMention = canCode && conversationNeedsCode(text, { rootContent: raw._threadRootContent })
       const replyDelivery = conversationDelivery(codingMention ? 'result' : 'reply', !codingMention)
-      const ctx = cid != null
+      let ctx = cid != null
         ? replyDelivery?.watcherOwned
           ? `The watcher verified this source message is addressed to you in OpenVisio channel ${cid}${who ? ` by "${who}"` : ''}: "${text}". ${codingMention ? 'Complete the concrete repository work and verification first.' : 'Answer the request directly.'} Do NOT call post_message; it is intentionally unavailable. Return only the final reply as your final answer. The watcher will re-check the live thread and render it at most once.${who ? ` To mention the requester, use their exact full name "@${who}".` : ''} The complete message is already here; do not call get_resource, get_marching_orders, poll_inbox, list_mcp_resources, or list_mcp_resource_templates.`
           : `The watcher verified this source message is addressed to you in OpenVisio channel ${cid}${who ? ` by "${who}"` : ''}: "${text}". ${codingMention ? `This is concrete repository work. Start the coding flow now. You may send at most one concrete progress update after work begins, but do not stop there: continue the work and then send one distinct final result with evidence or a real blocker. Use post_message for the final result even if you already sent a progress message` : 'Send EXACTLY ONE reply with post_message'}: arguments: channel_id ${cid}${threadRoot != null ? `, parent_id ${threadRoot} (reply IN THAT THREAD, do not start a new top-level message)` : ''}, plus agent_identifier + agent_api_key from the AUTH line above. Never repeat the same message.${who ? ` To @mention them back, write their EXACT full name "@${who}". A mention only links when the name matches exactly.` : ''} The complete message is already here. Do not call get_resource, get_marching_orders, poll_inbox, list_mcp_resources, or list_mcp_resource_templates.${codingMention ? ' Stop only after the work and final result/blocker.' : ' After your single reply, STOP.'}`
         : undefined
+      if (ctx && raw._threadRootContent) ctx += ` Verified thread root authored by you (context, not a new request): ${JSON.stringify(raw._threadRootContent)}. For requested repairs, inspect the referenced PR and its branch, run the failing verification, and fix that existing work. A review/testing handoff does not prevent an explicit human repair request.`
       if (codingMention) {
         // Activity indicators make accepted work visible. Do not add a canned
         // pickup message; the first channel message is the verified result or a
@@ -1957,6 +1701,39 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   log('up — backend WS watcher on ' + wsUrl + (canCode ? ' [code: ' + workdir + ']' : ''))
   handle = connectAgentWs({ wsUrl, apiKey, identifier, onEvent, onConnect: () => { setTimeout(() => void reconcileBacklog(), 250) }, log })
 
+  let authorizationProbeBusy = false
+  const legacyAuthorizationChecks = new Set()
+  const resumeReadyAuthorizations = async () => {
+    if (authorizationProbeBusy || (!blockedTasks.size && !failedTaskVersions.size)) return
+    authorizationProbeBusy = true
+    try {
+      // Older ACP adapters recorded a helper denial as a generic failed cycle.
+      // Recover that specific legacy state once, without reviving other failures.
+      for (const key of failedTaskVersions.keys()) {
+        const migrationKey = `pr-setup-migration:${key}`
+        if (blockedTasks.has(key) || legacyAuthorizationChecks.has(key) || memory.has(migrationKey)) continue
+        if (queues.work.has(`ticket:${key}`) || queues.reply.has(`ticket:${key}`)) continue
+        const [projectId, ticketId] = key.split(':').map(Number)
+        const cwd = findTicketWorktree(workdir, ticketId)
+        if (!cwd || !repositoryHasPrPushAuthorization({ cwd })) continue
+        const data = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
+        const ticket = data.ticket ?? data.task ?? data
+        legacyAuthorizationChecks.add(key)
+        if (!/OPENVISIO_PR_PUSH_AUTH_REQUIRED|openvisio-agent authorize-pr-push/.test(String(ticket.description || ''))) continue
+        memory.remember({ key: migrationKey, kind: 'migration', state: 'checked', summary: 'Recovered legacy PR setup block', refs: { projectId, ticketId } })
+        blockedTasks.add(key); blockedTaskRepos.set(key, cwd)
+      }
+      for (const key of [...blockedTasks]) {
+        if (queues.work.has(`ticket:${key}`) || queues.reply.has(`ticket:${key}`)) continue
+        if (!resumeAuthorized(key)) continue
+        const [projectId, id] = key.split(':').map(Number)
+        await handleTaskSignal('task:assigned', { task: { id, project_id: projectId } })
+      }
+    } catch (error) { log('Authorization resume failed: ' + (error?.message || error)) }
+    finally { authorizationProbeBusy = false }
+  }
+  const authorizationTimer = setInterval(() => void resumeReadyAuthorizations(), 2_000)
+  authorizationTimer.unref?.()
   let introTimer = null, taskProbeStartTimer = null, taskProbeTimer = null
   if (mcpConfig || mcpUrl) {
     // Workspace ethics: a one-time hello the FIRST time this agent ever connects.
@@ -1986,6 +1763,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const bye = async () => {
       if (stopping) return
       stopping = true
+      clearInterval(authorizationTimer)
       if (introTimer) clearTimeout(introTimer)
       if (taskProbeStartTimer) clearTimeout(taskProbeStartTimer)
       if (taskProbeTimer) clearInterval(taskProbeTimer)
@@ -1996,8 +1774,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
           void item.control.runner?.cancelCurrent?.()
         })
       }
-      await Promise.all([...replyRunners.values(), ...activeWorkRunners].map((runner) => runner.cancelCurrent?.()))
-      for (const runner of replyRunners.values()) runner.close?.()
+      await Promise.all([...activeReplyRunners, ...activeWorkRunners].map((runner) => runner.cancelCurrent?.()))
+      workRunners.close()
+      replyRunners.close()
       process.exit(0)
     }
     process.on('SIGTERM', bye)