openvisio-agent 0.19.11 → 0.20.0

package/src/watch.mjs

@@ -5,12 +5,13 @@
 // than written to disk from a pasted heredoc.
 
 import { spawn, spawnSync } from 'node:child_process'
+import { AsyncLocalStorage } from 'node:async_hooks'
 import { closeSync, writeFileSync, mkdirSync, existsSync, openSync, readFileSync, readdirSync, unlinkSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, dirname } from 'node:path'
 import { OV_DIR, DEFAULT_WORKSPACE, readConfig, writeJson, configPath, onPath, fail, ok, info, slugify, stripSlash, chmodSafe } from './lib.mjs'
 import { connectAgentWs, assertWebSocket } from './ws.mjs'
-import { agentAddedByName, blockingReplyMcpErrors, buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, combineRuntimeWorkEvidence, conversationAsksPendingTickets, conversationNeedsCode, failedTaskRevisionIsCurrent, mentionDedupeKeys, missingRuntimeWorkEvidence, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
+import { agentAddedByName, blockingReplyMcpErrors, buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, combineRuntimeWorkEvidence, conversationAsksPendingTickets, conversationNeedsCode, failedTaskRevisionIsCurrent, mentionDedupeKeys, messageParentId, messageSenderIsSelf, missingRuntimeWorkEvidence, normalizeRenderedMessageText, renderedAgentMessages, taskBelongsToAgent, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
 import { createMastraMemory } from './memory.mjs'
 import { repositoryHasPrPushAuthorization, configurePrPublishing } from './pr-push.mjs'
 import { createMcpHttpClient } from './mcp-http.mjs'
@@ -20,10 +21,24 @@ 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'
 import { claudeFallbackModels, resolveClaudeModel } from './model-selection.mjs'
+import { createAgentJournal } from './agent-journal.mjs'
+
+function runtimeJournal(options, supplied) {
+  let journal
+  try { journal = supplied || createAgentJournal(options) } catch { /* studio is optional */ }
+  return {
+    runId: journal?.runId || `${process.pid}-${Date.now()}`,
+    emit(type, data) {
+      try { Promise.resolve(journal?.emit(type, data)).catch(() => {}) } catch { /* telemetry cannot block work */ }
+    },
+    async close() { try { await journal?.close() } catch { /* shutdown must finish without the viewer */ } },
+  }
+}
 
 function findTicketWorktree(workspaceRoot, ticketId) {
   if (!workspaceRoot || ticketId == null) return ''
@@ -318,13 +333,13 @@ export async function runWatch({ flags }) {
 }
 
 // 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 }) {
+export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model, onTool, onEvent, 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, canCoordinate, maxCycleMs, log, debug, model, onTool, systemPrompt })
+  const mastraRunner = createMastraAcpRunner({ agent, mcpUrl, mcpHeaders, workdir, canCode, canCoordinate, maxCycleMs, log, debug, model, onTool, onEvent, systemPrompt })
   if (mastraRunner) return mastraRunner
   let child = null
   // The model the CURRENT session was spawned with. runCycle can pass a different
@@ -346,11 +361,20 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
   let turnDidMcpTaskRead = false
   let turnDidMcpTaskUpdate = false
   let turnOutputText = ''
+  let turnCycleId = null
+  let turnRuntimePid = null
+  const childCycleIds = new WeakMap()
+  const safeText = (value, max = 2000) => Object.values(mcpHeaders || {}).filter(Boolean).reduce((text, secret) => text.split(String(secret)).join('[redacted]'), String(value || '')).slice(0, max)
+  const emit = (type, data = {}) => {
+    try { Promise.resolve(onEvent?.(type, { cycleId: turnCycleId, provider: agent, runtime: 'claude-stream', watcherPid: process.pid, runtimePid: turnRuntimePid, workdir: workdir || '', model: sessionModel, ...data })).catch(() => {}) } catch { /* telemetry is best effort */ }
+  }
   const clearCycleTimer = () => { if (cycleTimer) { clearTimeout(cycleTimer); cycleTimer = null } }
   const settleTurn = (o) => {
     clearCycleTimer()
     const r = resolveTurn
     resolveTurn = null
+    const finalText = typeof o.result === 'string' ? o.result.trim() : turnOutputText.trim()
+    if (r && finalText) emit('output.final', { text: safeText(finalText, 8000), status: o.subtype || 'ok' })
     const mcpCalls = [...turnToolCalls]
     if (r) r({
       ...o,
@@ -392,6 +416,9 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
     const args = canCode ? [...base, '--allowedTools', ...CODE_TOOLS, '--disallowedTools', ...DENY_TOOLS] : [...base, '--allowedTools', 'mcp__openvisio-team__*']
     const c = spawn(claude, args, { ...modelProcessOptions, cwd: workdir || undefined, stdio: ['pipe', 'pipe', 'inherit'] })
     child = c
+    turnRuntimePid = c.pid || null
+    childCycleIds.set(c, turnCycleId)
+    emit('process.started', { status: 'starting' })
     turnsThisSession = 0
     sessionStartedAt = Date.now()
     let localBuf = ''
@@ -403,6 +430,26 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
         const line = localBuf.slice(0, i); localBuf = localBuf.slice(i + 1)
         if (!line.trim()) continue
         let o; try { o = JSON.parse(line) } catch { continue }
+        if (o.type === 'system' && o.subtype === 'init') emit('process.ready', { status: 'running', sessionId: typeof o.session_id === 'string' ? o.session_id : null })
+        if (o.type === 'assistant' && Array.isArray(o.message?.content)) {
+          for (const block of o.message.content) {
+            if (block.type === 'tool_use') {
+              const title = block.name === 'Bash' && typeof block.input?.command === 'string' ? block.input.command : block.name
+              const filePath = ['Read', 'Write', 'Edit', 'MultiEdit', 'Grep', 'Glob'].includes(block.name) ? block.input?.file_path || block.input?.path : ''
+              emit('tool.started', { toolCallId: safeText(block.id, 200), name: safeText(block.name, 300), title: safeText(title, 2000), status: 'in_progress', locations: typeof filePath === 'string' && filePath ? [{ path: safeText(filePath, 1000) }] : [] })
+              // TodoWrite is an explicit published plan, not model reasoning.
+              if (block.name === 'TodoWrite' && Array.isArray(block.input?.todos)) emit('plan.updated', { entries: block.input.todos.slice(0, 100).map((entry) => ({ content: safeText(entry.content), status: ['pending', 'in_progress', 'completed'].includes(entry.status) ? entry.status : 'unknown', priority: entry.priority })) })
+            } else if (block.type === 'text' && block.text) emit('output.progress', { messageId: typeof o.message.id === 'string' ? o.message.id : null, text: safeText(block.text, 8000) })
+          }
+        }
+        if (o.type === 'user' && Array.isArray(o.message?.content)) {
+          for (const block of o.message.content) if (block.type === 'tool_result') {
+            const use = turnToolUses.get(block.tool_use_id)
+            const title = use?.name === 'Bash' && typeof use.input?.command === 'string' ? use.input.command : use?.name || 'tool'
+            const filePath = ['Read', 'Write', 'Edit', 'MultiEdit', 'Grep', 'Glob'].includes(use?.name) ? use.input?.file_path || use.input?.path : ''
+            emit('tool.finished', { toolCallId: safeText(block.tool_use_id, 200), name: safeText(use?.name || 'tool', 300), title: safeText(title), status: block.is_error ? 'failed' : 'completed', locations: typeof filePath === 'string' && filePath ? [{ path: safeText(filePath, 1000) }] : [] })
+          }
+        }
         if (debug) logEvent(o)
         const evidence = claudeEventEvidence(o, turnToolUses)
         if (evidence.outputText) turnOutputText += (turnOutputText ? ' ' : '') + evidence.outputText
@@ -440,13 +487,15 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
     })
     c.on('exit', (code) => { if (c !== child) { log('old session exited ' + code); return } log('session exited ' + code); child = null; settleTurn({ type: 'result', subtype: 'exit' }) })
     c.on('error', () => { if (c !== child) return; child = null; settleTurn({ type: 'result', subtype: 'error' }) })
+    c.on('close', (code, signal) => emit('process.stopped', { cycleId: childCycleIds.get(c) ?? null, runtimePid: c.pid || null, status: 'exited', exitCode: code, signal }))
     log('warm session started' + (sessionModel ? ' [model ' + sessionModel + ']' : '') + (canCode
       ? ' [CODE mode — workspace ' + workdir + ' — finds/clones the org\'s repos here, branches, pushes, opens PRs]'
       : ' [CHAT-ONLY mode (--chat-only) — chat/ticket tools only, no code work]'))
   }
 
-  function runCycle(prompt, cycleModel) {
+  function runCycle(prompt, cycleModel, cycleOptions = {}) {
     return new Promise((resolve) => {
+      turnCycleId = cycleOptions.cycleId ?? null
       // A per-cycle model override (e.g. chat on a cheaper model than code) — a
       // change means the warm session must be respawned with the new --model.
       const resolvedCycleModel = resolveClaudeModel(cycleModel)
@@ -461,6 +510,7 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
         child = null
       }
       ensureSession()
+      if (child) childCycleIds.set(child, turnCycleId)
       turnsThisSession++
       turnToolCalls = new Set()
       turnToolUses = new Map()
@@ -502,8 +552,35 @@ function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfi
 // One WebSocket identity feeds independent serialized work/reply queues. Each
 // accepted source keeps its own context; direct MCP reconciliation recovers work
 // without model spend while idle.
-function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug }) {
-  const log = (m) => process.stdout.write('[ws ' + new Date().toISOString() + '] ' + m + '\n')
+function loopBackendWs(options) {
+  const watcher = createBackendWatcher(options)
+  const stop = () => void watcher.close().then(() => process.exit(0))
+  process.once('SIGTERM', stop)
+  process.once('SIGINT', stop)
+  return watcher.done
+}
+
+// Production orchestration with replaceable I/O boundaries for deterministic
+// workspace simulations. Tests run this same routing, queue and delivery code.
+export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug, claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug }, dependencies = {}) {
+  const validBackendId = (value) => value != null && /^\d+$/.test(String(value)) && Number.isSafeInteger(Number(value)) && Number(value) > 0
+  const stateDir = dependencies.stateDir || OV_DIR
+  const makeRunner = dependencies.createRunner || createCycleRunner
+  const autoStart = dependencies.autoStart !== false
+  let stopping = false
+  const pendingOperations = new Set()
+  const trackOperation = (promise) => {
+    const tracked = Promise.resolve(promise).finally(() => pendingOperations.delete(tracked))
+    pendingOperations.add(tracked)
+    return tracked
+  }
+  const log = dependencies.log || ((m) => process.stdout.write('[ws ' + new Date().toISOString() + '] ' + m + '\n'))
+  const journal = runtimeJournal({ stateDir, agent: { identifier, slug, provider: agent }, secrets: [apiKey] }, dependencies.journal)
+  const emit = (type, data = {}) => journal.emit(type, { watcherPid: process.pid, ...data })
+  let cycleSequence = 0
+  let mcpSequence = 0
+  const cycleContext = new AsyncLocalStorage()
+  emit('watcher.started', { status: 'running', model, chatModel, workdir: workdir || '' })
   let handle = null
   // Activity belongs to an individual cycle. Independent ticket workers must
   // not clear or overwrite each other's status targets.
@@ -518,20 +595,20 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   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.`
+  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: discover an advertised ticket-comment action and follow its input schema; never invent a tool name or call an unadvertised action. 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.`
   // 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 },
-    cfgKey: identifier, mcpConfig, workdir, log, debug, model, systemPrompt,
+    cfgKey: identifier, mcpConfig, workdir, log, debug, model, systemPrompt, onEvent: emit,
   }
   // One watcher and one WS subscription, with a bounded pool of isolated coding
-  // runtimes. Replies remain serialized so one agent cannot answer two messages
-  // at once and race duplicate-delivery guards.
+  // runtimes. Replies serialize within a thread while independent threads run
+  // concurrently behind the same delivery guards.
   const MAX_CONCURRENT_WORKERS = 3
   const activeWorkRunners = new Set()
-  const createWorkRunner = (control, workerWorkdir = '') => createCycleRunner({
+  const createWorkRunner = (control, workerWorkdir = '') => makeRunner({
     ...runnerOptions,
     ...(workerWorkdir ? { workdir: workerWorkdir } : {}),
     onTool: (name) => { if (/post_message/.test(name)) emitStatusTargets(control.statusTargets, 'typing') },
@@ -543,7 +620,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   const activeReplyRunners = new Set()
   const replyRunners = createRunnerPool({
     capacity: 8,
-    create: ({ key, canCoordinate }) => createCycleRunner({
+    create: ({ key, canCoordinate }) => makeRunner({
       ...runnerOptions, workdir: '', canCoordinate,
       systemPrompt: CHAT_CHARTER + '\n\n' + credNote,
       cfgKey: identifier + '-reply-' + slugify(key),
@@ -552,7 +629,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   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. 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 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. For ticket comments, discover an advertised action and follow its input schema; never invent a tool name or call an unadvertised action.'
   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
   const fastPrompt = (canCode ? CODE_FAST : CYCLE_FAST) + '\n\n' + backendToolRule
   const coordinatePrompt = COORDINATE + '\n\n' + backendToolRule
@@ -572,7 +649,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         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) }
+        try { return await cycleContext.run({ cycleId: item.control.cycleId }, () => executeCycle(item.kind, item.context, item.targetChannels, item.taskRef, item.delivery, runner, item.control, item.workdir)) }
         finally { workRunners.release(sessionKey); activeWorkRunners.delete(runner); item.control.runner = null }
       },
       onError: (error, item) => {
@@ -589,7 +666,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         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, '') }
+        try { return await cycleContext.run({ cycleId: item.control.cycleId }, () => executeCycle(item.kind, item.context, item.targetChannels, item.taskRef, item.delivery, runner, item.control, '')) }
         finally { replyRunners.release(key); activeReplyRunners.delete(runner); item.control.runner = null }
       },
       onError: (error, item) => {
@@ -606,16 +683,17 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   // Mentions we've already reacted to (by message id) — the backend can re-deliver
   // an agent:mention (reconnect replay, dup fan-out), which otherwise makes the
   // agent reply to the SAME message twice.
-  const replayPath = join(OV_DIR, 'watch-' + slug + '-replay.json')
+  const replayPath = join(stateDir, 'watch-' + slug + '-replay.json')
   let replayState = {}
   try { replayState = JSON.parse(readFileSync(replayPath, 'utf8')) } catch { /* first run */ }
   const seenMentions = new Set(Array.isArray(replayState.seenMentions) ? replayState.seenMentions : [])
   const recentMentionSignatures = new Map(Array.isArray(replayState.recentMentionSignatures) ? replayState.recentMentionSignatures : [])
   const seenActivities = new Set(Array.isArray(replayState.seenActivities) ? replayState.seenActivities : [])
   const deliveredReplies = new Set(Array.isArray(replayState.deliveredReplies) ? replayState.deliveredReplies : [])
-  const memory = createMastraMemory({
-    ledgerPath: join(OV_DIR, 'watch-' + slug + '-memory.json'),
-    databasePath: join(OV_DIR, 'watch-' + slug + '-mastra.db'),
+  const pendingReplyDeliveries = new Map(Array.isArray(replayState.pendingReplyDeliveries) ? replayState.pendingReplyDeliveries : [])
+  const memory = dependencies.memory || createMastraMemory({
+    ledgerPath: join(stateDir, 'watch-' + slug + '-memory.json'),
+    databasePath: join(stateDir, 'watch-' + slug + '-mastra.db'),
     resourceId: identifier,
   })
   // Completion delivery is runtime-owned for assigned coding work. Persist both
@@ -628,9 +706,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   // This is distinct from a policy block: any later human ticket change resumes
   // the work, but reconnects and the watcher's own blocker update do not.
   const failedTaskVersions = new Map(Array.isArray(replayState.failedTaskVersions) ? replayState.failedTaskVersions : [])
-  // A policy-blocked task stays paused across reconnects. It is released only
-  // after the ticket itself carries explicit authorization or is completed/
-  // unassigned. This prevents a 30-minute reconciliation retry from repeatedly
+  // A policy-blocked task stays paused across reconnects. Helper blocks are
+  // released by verified local configuration, or cleared when completed/unassigned. This prevents a 30-minute reconciliation retry from repeatedly
   // attempting the same rejected egress action.
   const blockedTasks = new Set(Array.isArray(replayState.blockedTasks) ? replayState.blockedTasks : [])
   const blockedTaskRepos = new Map(Array.isArray(replayState.blockedTaskRepos) ? replayState.blockedTaskRepos : [])
@@ -650,6 +727,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         recentMentionSignatures: [...recentMentionSignatures],
         seenActivities: [...seenActivities],
         deliveredReplies: [...deliveredReplies],
+        pendingReplyDeliveries: [...pendingReplyDeliveries],
         failedTaskVersions: [...failedTaskVersions],
         blockedTasks: [...blockedTasks],
         blockedTaskRepos: [...blockedTaskRepos],
@@ -712,7 +790,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   const markMentionHandled = (message, channelId) => {
     pruneMentionSignatures()
     const { idKey, signatureKey } = mentionDedupeKeys(message, channelId)
-    const duplicate = (idKey && seenMentions.has(idKey)) || (signatureKey && recentMentionSignatures.has(signatureKey))
+    const duplicate = idKey ? seenMentions.has(idKey) : !!signatureKey && recentMentionSignatures.has(signatureKey)
     if (duplicate) return true
     if (idKey) { seenMentions.add(idKey); trimSeen(seenMentions) }
     if (signatureKey) recentMentionSignatures.set(signatureKey, Date.now())
@@ -724,19 +802,46 @@ 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 lastInboxSignature = ''
   let selfAgentId = null
+  let selfOrganizationId = null
   let completionRecipientName = ''
   const selfAliases = new Set([slug, identifier].map((value) => String(value || '').toLowerCase()).filter(Boolean))
   const rememberSelfAgent = (self) => {
-    if (!self || typeof self !== 'object') return
+    if (!self || typeof self !== 'object' || String(self.identifier || self.slug || '') !== identifier) return
     if (self.id != null) selfAgentId = Number(self.id)
     for (const alias of [self.name, self.identifier, self.slug]) if (alias) selfAliases.add(String(alias).toLowerCase())
     const addedBy = agentAddedByName(self)
     if (addedBy) completionRecipientName = addedBy
+    const organizationId = self.organization_id ?? self.organizationId
+    if (validBackendId(organizationId)) {
+      selfOrganizationId = Number(organizationId)
+      handle?.subscribeOrganization?.(selfOrganizationId)
+    }
+  }
+  const mcpClient = dependencies.mcpClient || createMcpHttpClient({ url: mcpUrl, apiKey, identifier, clientVersion: '0.18.5', log })
+  const callMcpTool = (name, args = {}) => {
+    if (stopping) return Promise.reject(new Error('Watcher is stopping'))
+    const toolCallId = `${journal.runId}:mcp:${++mcpSequence}`
+    const metadata = { cycleId: cycleContext.getStore()?.cycleId || null, toolCallId, name, title: name, source: 'watcher', provider: agent, runtime: 'watcher', locations: [] }
+    emit('tool.started', { ...metadata, status: 'in_progress' })
+    return trackOperation(Promise.resolve().then(() => mcpClient.callTool(name, args)).then((result) => {
+      emit('tool.finished', { ...metadata, status: 'completed' })
+      return result
+    }, (error) => {
+      emit('tool.finished', { ...metadata, status: 'failed' })
+      throw error
+    }))
+  }
+  let selfRead = null
+  const ensureSelfAgent = async () => {
+    if (selfAgentId != null) return
+    if (!selfRead) selfRead = callMcpTool('list_agents').then(toolData).then((data) => {
+      const self = (Array.isArray(data.agents) ? data.agents : []).find((row) => String(row.identifier || row.slug || '') === identifier)
+      if (!self?.id) throw new Error('list_agents did not return this BYO agent')
+      rememberSelfAgent(self)
+    }).finally(() => { selfRead = null })
+    await selfRead
   }
-  const mcpClient = createMcpHttpClient({ url: mcpUrl, apiKey, identifier, clientVersion: '0.18.5', log })
-  const callMcpTool = (name, args = {}) => mcpClient.callTool(name, args)
   let mcpToolNames = null
   let mcpToolDiscoveryPromise = null
   let mcpToolDiscoveryWarned = false
@@ -755,24 +860,25 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     }).finally(() => { mcpToolDiscoveryPromise = null })
     return mcpToolDiscoveryPromise
   }
-  const mcpSupports = async (name) => {
-    try { return (await discoverMcpTools()).has(name) }
+  const callOptionalTicketComment = async ({ projectId, ticketId, content }) => {
+    let names
+    try { names = await discoverMcpTools() }
     catch (e) {
       if (!mcpToolDiscoveryWarned) {
         mcpToolDiscoveryWarned = true
         log('MCP tool discovery failed; optional actions will use compatibility fallbacks: ' + (e?.message || e))
       }
-      return null
+      return { called: false, reason: 'discovery-unavailable' }
     }
-  }
-  const callOptionalMcpTool = async (name, args) => {
-    const supported = await mcpSupports(name)
-    if (supported !== true) return { called: false, reason: 'not-advertised' }
-    try { return { called: true, result: await callMcpTool(name, args) } }
+    // Select once from advertised capabilities. A failed write may already have
+    // reached the server, so never try another comment endpoint after an error.
+    const name = names.has('create_task_comment') ? 'create_task_comment' : names.has('comment_ticket') ? 'comment_ticket' : ''
+    if (!name) return { called: false, reason: 'not-advertised' }
+    const args = { project_id: projectId, ticket_id: ticketId, ...(name === 'create_task_comment' ? { content } : { text: content }) }
+    try { return { called: true, tool: name, result: await callMcpTool(name, args) } }
     catch (e) {
       if (/\b(?:unknown|missing|unsupported) tool\b|\btool\b.*\bnot found\b/i.test(String(e?.message || e))) {
         try { await discoverMcpTools(true) } catch { /* the original error is enough */ }
-        return { called: false, reason: 'not-available' }
       }
       throw e
     }
@@ -811,9 +917,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const tasksData = toolData(tasksResult)
       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 ?? '')
-        const assignedHere = (selfAgentId != null && assignedId === selfAgentId) || assignedIdentifier === identifier
+        const assignedHere = taskBelongsToAgent(task, { id: selfAgentId, identifier })
         return assignedHere && !taskIsCompleted(task, doneIds)
       }).map((task) => ({
         id: task.id,
@@ -858,9 +962,19 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   // rendered as this agent. A persisted delivery key closes the crash/reconnect
   // gap; an in-flight promise closes the two-lane race inside one watcher.
   const messageDeliveries = new Map()
-  const threadControlKey = (channelId, parentId) => Number.isFinite(Number(channelId)) && parentId != null ? `thread:${Number(channelId)}:${parentId}` : ''
+  const threadControlKey = (channelId, parentId) => validBackendId(channelId) && validBackendId(parentId) ? `thread:${Number(channelId)}:${parentId}` : ''
   const sameDeliveryThread = (delivery, channelId, parentId) => delivery && Number(delivery.channelId) === Number(channelId) && String(delivery.parentId ?? '') === String(parentId ?? '')
   const cancelThread = (channelId, parentId, summary) => {
+    // A subsequent explicit mention may reactivate the thread. Remove replies
+    // belonging to the canceled request now so reactivation cannot revive them.
+    for (const [key, delivery] of pendingReplyDeliveries) {
+      if (!sameDeliveryThread(delivery, channelId, parentId)) continue
+      pendingReplyDeliveries.delete(key)
+      deliveredReplies.add(key)
+      memory.remember({ key, kind: 'delivery', state: 'suppressed', summary: 'The source request was cancelled.', refs: { channelId, threadId: parentId } })
+    }
+    trimSeen(deliveredReplies)
+    persistReplay()
     const controlKey = threadControlKey(channelId, parentId)
     if (!controlKey) return
     memory.remember({ key: controlKey, kind: 'thread', state: 'cancelled', summary, refs: { channelId: Number(channelId), threadId: parentId } })
@@ -876,7 +990,27 @@ 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 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 }) => {
+    if (stopping) throw new Error('Watcher is stopping')
     const deliveryKey = String(key || '')
     if (parentId == null) {
       channelId = await projectStatusChannel(projectId)
@@ -884,12 +1018,17 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       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' }
+    if (!deliveryKey || !validBackendId(channelId) || (parentId != null && !validBackendId(parentId)) || !message) return { posted: false, reason: 'invalid-delivery' }
+    if (deliveredReplies.has(deliveryKey) || memory.has(deliveryKey, 'rendered')) {
+      if (pendingReplyDeliveries.delete(deliveryKey)) persistReplay()
+      return { posted: false, reason: 'remembered' }
+    }
     if (messageDeliveries.has(deliveryKey)) return messageDeliveries.get(deliveryKey)
     const controlKey = threadControlKey(channelId, parentId)
     const suppressCancelled = () => {
+      if (memory.has(deliveryKey, 'suppressed')) return { posted: false, reason: 'source-cancelled' }
       if (allowCancelled || !controlKey || !memory.has(controlKey, 'cancelled')) return null
+      pendingReplyDeliveries.delete(deliveryKey)
       deliveredReplies.add(deliveryKey); trimSeen(deliveredReplies); persistReplay()
       memory.remember({ key: deliveryKey, kind: 'delivery', state: 'suppressed', summary: 'A newer redirect or stand-down cancelled this reply.', refs: { channelId: Number(channelId), threadId: parentId } })
       return { posted: false, reason: 'thread-cancelled' }
@@ -897,6 +1036,12 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const initiallyCancelled = suppressCancelled()
     if (initiallyCancelled) return initiallyCancelled
 
+    // Store generated threaded replies before delivery. A transport outage must
+    // retry the authoritative delivery check, not pay for another model turn.
+    if (parentId != null) {
+      pendingReplyDeliveries.set(deliveryKey, { key, channelId, parentId, projectId, content: message, skipIfAnyAgentReply, sourceKey, sourceMessageId, allowCancelled })
+      persistReplay()
+    }
     const run = (async () => {
       if (parentId != null) {
         const live = toolData(await callMcpTool('list_message_thread', { channel_id: Number(channelId), message_id: Number(parentId) }))
@@ -915,6 +1060,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       // Re-check immediately before the irreversible post.
       const newlyCancelled = suppressCancelled()
       if (newlyCancelled) return newlyCancelled
+      if (stopping) throw new Error('Watcher is stopping')
 
       sendStatus(Number(channelId), 'typing')
       const result = toolData(await callMcpTool('post_message', {
@@ -923,15 +1069,32 @@ 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')
       return { posted: true, result }
-    })().finally(() => messageDeliveries.delete(deliveryKey))
+    })().then((result) => {
+      if (pendingReplyDeliveries.delete(deliveryKey)) persistReplay()
+      return result
+    }).finally(() => messageDeliveries.delete(deliveryKey))
     messageDeliveries.set(deliveryKey, run)
     return run
   }
 
+  let deliveryProbeBusy = false
+  const flushPendingReplies = async () => {
+    if (stopping || deliveryProbeBusy) return
+    deliveryProbeBusy = true
+    try {
+      await mapConcurrent([...pendingReplyDeliveries.values()], 3, async (delivery) => {
+        try { await postMessageOnce(delivery) }
+        catch (error) { log('reply remains pending: ' + (error?.message || error)) }
+      })
+    } finally { deliveryProbeBusy = false }
+  }
+
   const statusChannelCache = new Map()
   let dedicatedChannelRead = null
   const projectStatusChannel = async (projectId) => {
@@ -982,7 +1145,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const taskKey = `${projectId}:${ticketId}`
     const current = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
     const ticket = current.ticket ?? current.task ?? current
-    const report = buildTaskCompletionReport(ticket, { projectId, fallbackText: result.outputText, recipientName: completionRecipientName })
+    const completionTypes = await taskTypeSets(projectId)
+    const report = buildTaskCompletionReport(ticket, { projectId, fallbackText: result.outputText, recipientName: completionRecipientName, completedTypeIds: completionTypes.done, reviewTypeIds: completionTypes.review })
     if (!report) return false
     const memoryKey = `ticket:${projectId}:${ticketId}`
     memory.remember({
@@ -998,9 +1162,9 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     // handoff or trap the ticket in reconnect retries.
     if (!reportedTaskComments.has(report.key)) {
       try {
-        const comment = await callOptionalMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: report.content })
+        const comment = await callOptionalTicketComment({ projectId, ticketId, content: 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 dedicated-channel report')
+        else log('no ticket comment tool is 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 dedicated-channel report')
       }
@@ -1066,10 +1230,13 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       refs: { projectId, ticketId, ...(Number.isFinite(channelId) ? { channelId } : {}) },
     })
     try {
-      const comment = await callOptionalMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: ticketNotice })
+      const comment = await callOptionalTicketComment({ projectId, ticketId, content: ticketNotice })
       if (comment.called) { delivered = true; return }
-      log('comment_ticket is not exposed; recording the blocker in the ticket description for #' + ticketId)
-    } catch (e) { log('optional ticket comment failed; recording the blocker in the ticket description for #' + ticketId) }
+      log('no ticket comment tool is exposed; recording the blocker in the ticket description for #' + ticketId)
+    } catch (e) {
+      log('ticket comment outcome is uncertain for #' + ticketId + '; no alternate ticket write will be attempted: ' + (e?.message || e))
+      throw e
+    }
     const current = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
     const ticket = current.ticket ?? current.task ?? current
     const description = String(ticket.description || '')
@@ -1099,17 +1266,15 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     }
     const command = block?.command || 'the requested external repository action'
     const payload = [block?.commit && `commit ${block.commit}`, block?.branch && `branch ${block.branch}`, block?.remote && `remote ${block.remote}`].filter(Boolean).join(', ')
-    const approval = block?.commit && block?.branch
-      ? `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 dedicated agent channel; I won't retry automatically.`
+    const notice = `The local runtime rejected \`${command}\`${payload ? ` (${payload})` : ''}. Routine agent PR publishing uses the configured \`openvisio-agent push-pr-branch\` helper. This rejection needs a local runtime policy change; a channel reply cannot change that policy. I've paused the ticket and have not published the rejected action.`
+    const ticketNotice = notice
     return publishBlocker({ prompt, taskRef, delivery, notice, ticketNotice, pause: true })
   }
 
   // Reconcile everything that may have arrived while disconnected. This spends no
   // model tokens unless the tools actually report pending work.
   const reconcileBacklog = async () => {
+    if (stopping) return
     if (!mcpUrl || backlogProbeBusy) return
     backlogProbeBusy = true
     try {
@@ -1131,9 +1296,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
           ])
           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
+            if (!taskBelongsToAgent(task, { id: selfAgentId, 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 } })
@@ -1185,7 +1348,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
             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 activityParentId = messageParentId(activityMessage)
             const activityThreadRoot = activityParentId != null ? activityParentId : activityMessageId
             const activityControlKey = threadControlKey(activityChannelId, activityThreadRoot)
             const ownedActivity = !!activityControlKey && memory.has(activityControlKey, 'active')
@@ -1193,7 +1356,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
             // 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
+            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.
@@ -1203,36 +1366,36 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
               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
+                if (memory.has(activitySourceKey, 'received')) continue
               }
               mentionActivity.push({
                 projectId: project.id,
                 project: project.name,
                 channelId: activityChannelId,
                 message: activityMessage,
-                activity: item,
+                activity: item, activityKey,
               })
             }
           }
         } 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
+      if (mentionActivity.length) {
         log('backlog reconciliation found ' + mentionActivity.length + ' mention(s) -> guarded reply cycle(s)')
         // Replay each real message through the exact same delivery path as a live
         // WebSocket mention. This preserves thread ids and lets postMessageOnce
         // consult the rendered thread before any reply is emitted.
         for (const mention of mentionActivity) {
-          onEvent('agent:mention', {
+          void onEvent('agent:mention', {
             project_id: mention.projectId,
             channel_id: mention.channelId,
             message: mention.message,
             _mentionAlreadyMarked: true,
+          })?.then((result) => {
+            if (result?.status === 'retry') { seenActivities.delete(mention.activityKey); persistReplay() }
           })
         }
-      } else if (!mentionActivity.length) lastInboxSignature = ''
+      }
     } catch (e) {
       log('backlog reconciliation failed: ' + (e && e.message ? e.message : e))
     } finally { backlogProbeBusy = false }
@@ -1257,22 +1420,35 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   }
 
   function drain(kind, context, targetChannels = [], taskRef = null, delivery = null) {
+    if (stopping) return Promise.resolve({ status: 'canceled' })
     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(), enqueuedAt: performance.now() }
-    return queues[laneName].enqueue({ kind, context, targetChannels, taskRef, delivery, workdir: itemWorkdir, control }, key)
+    if (key != null && queues[laneName].has(key)) return queues[laneName].enqueue(null, key)
+    const cycleId = `${journal.runId}:cycle:${++cycleSequence}`
+    const control = { cycleId, outcome: 'queued', cancelled: false, runner: null, statusTargets: new Set(), enqueuedAt: performance.now() }
+    const cycleData = { cycleId, kind, lane: laneName, model: kind === 'full' ? codeModel : liteModel, workdir: itemWorkdir || (laneName === 'work' ? workdir : ''), ...(taskRef ? { ticket: { projectId: taskRef.projectId, ticketId: taskRef.ticketId } } : {}), ...(delivery ? { thread: { channelId: delivery.channelId, threadId: delivery.parentId } } : {}) }
+    emit('cycle.queued', { ...cycleData, status: 'queued' })
+    return queues[laneName].enqueue({ kind, context, targetChannels, taskRef, delivery, workdir: itemWorkdir, control }, key).then((result) => {
+      const status = control.cancelled || result?.status === 'canceled' ? 'canceled' : result?.status === 'failed' ? 'error' : control.outcome
+      emit(status === 'canceled' ? 'cycle.cancelled' : 'cycle.finished', { ...cycleData, status, durationMs: Math.round(performance.now() - (control.startedAt ?? control.enqueuedAt)) })
+      return result
+    })
   }
 
   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()
+    cycleControl.startedAt = cycleStartedAt
+    cycleControl.outcome = 'skipped'
+    emit('cycle.started', { cycleId: cycleControl.cycleId, kind, lane: laneName, status: 'preflight', model: kind === 'full' ? codeModel : liteModel, workdir: preparedWorkdir || (kind === 'full' ? workdir : ''), ...(taskRef ? { ticket: { projectId: taskRef.projectId, ticketId: taskRef.ticketId } } : {}), ...(delivery ? { thread: { channelId: delivery.channelId, threadId: delivery.parentId } } : {}), queueMs: Math.round(cycleStartedAt - (cycleControl.enqueuedAt ?? cycleStartedAt)) })
     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) : '')
     const runnerOptions = {
+      cycleId: cycleControl.cycleId, attempt: 1,
       ...(delivery?.watcherOwned ? { disabledMcpTools: ['post_message'] } : {}),
       ...(ticketWorktree ? { workdir: ticketWorktree } : {}),
     }
@@ -1302,10 +1478,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         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) ||
+            !taskBelongsToAgent(ticket, { id: selfAgentId, identifier }) ||
             taskIsCompleted(ticket, typeSets.done) || taskIsAwaitingReview(ticket, typeSets.review)) {
           releaseTaskForRetry(activeTaskRef, prompt)
           log('queued ticket no longer actionable; skipped before model start')
@@ -1313,8 +1487,10 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
         }
       }
       if (cycleControl.cancelled) return
+      cycleControl.outcome = 'running'
       log(`cycle timing preflight=${Math.round(performance.now() - cycleStartedAt)}ms kind=${kind}`)
       const result = await runner.runCycle(prompt, useModel, runnerOptions)
+      cycleControl.outcome = result?.subtype || 'ok'
       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
@@ -1347,6 +1523,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       }
       const replyMutationErrors = kind !== 'full' ? blockingReplyMcpErrors(result?.mcpErrors) : []
       if (replyMutationErrors.length) {
+        cycleControl.outcome = 'blocked'
         const notice = `I couldn't complete the requested OpenVisio action: ${replyMutationErrors.join(', ')}. I haven't claimed that change succeeded.`
         log('COORDINATION_CYCLE_BLOCKED failed MCP calls; publishing blocker')
         try { await publishBlocker({ prompt, taskRef: activeTaskRef, delivery, notice }) }
@@ -1362,13 +1539,17 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const resultMessageRequired = kind === 'full' && !!delivery && !delivery.watcherOwned
       const missing = missingRuntimeWorkEvidence(result, { ticketCycle, resultMessageRequired })
       if (kind === 'full' && cycleSucceeded(result) && missing.length) {
+        cycleControl.outcome = 'recovering'
+        emit('cycle.recovery', { cycleId: cycleControl.cycleId, kind, status: 'recovering', attempt: 2, missing })
         log(agent + ' coding cycle incomplete; recovery requires: ' + missing.join(', '))
         const recoveryPrompt = `CONTINUE THE SAME OPENVISIO REQUEST. Your earlier output did not complete it. Missing runtime evidence: ${missing.join('; ')}. An intent or progress message is not completion. Continue the actual work now, verify it, and then provide one distinct final result or real blocker using the original delivery rule; a final result after an earlier progress message is explicitly allowed and required. Do not repeat the progress message. ${codexPushGuide}\n\nORIGINAL REQUEST AND ROUTING CONTEXT:\n${prompt}`
-        const recovery = await runner.runCycle(recoveryPrompt, codeModel, runnerOptions)
+        const recovery = await runner.runCycle(recoveryPrompt, codeModel, { ...runnerOptions, attempt: 2 })
+        cycleControl.outcome = recovery?.subtype || 'ok'
         if (cycleControl.cancelled || recovery?.subtype === 'canceled') return
         const recoveredResult = combineRuntimeWorkEvidence(result, recovery)
         const recoveryMissing = missingRuntimeWorkEvidence(recoveredResult, { ticketCycle, resultMessageRequired })
         if (!cycleSucceeded(recovery) || recoveryMissing.length) {
+          cycleControl.outcome = 'blocked'
           if (recovery?.subtype === 'blocked' && recovery?.policyBlock) {
             try { await reportPolicyBlock(prompt, activeTaskRef, recovery.policyBlock, delivery) }
             catch (e) { log('failed to publish recovery policy blocker: ' + (e?.message || e)) }
@@ -1454,7 +1635,7 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     const hinted = taskFromEvent(raw)
     const ticketId = hinted && (hinted.id ?? hinted.task_id ?? hinted.taskId)
     const projectId = hinted && (hinted.project_id ?? hinted.projectId ?? raw.project_id ?? raw.projectId)
-    if (ticketId == null || projectId == null) { log(kind + ' missing ticket/project identity — ignored'); return }
+    if (!validBackendId(ticketId) || !validBackendId(projectId)) { log(kind + ' missing ticket/project identity — ignored'); return }
     try {
       if (selfAgentId == null) {
         const agentsData = toolData(await callMcpTool('list_agents'))
@@ -1464,10 +1645,9 @@ 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
+      if (String(ticket.id) !== String(ticketId) || (ticket.project_id != null && String(ticket.project_id) !== String(projectId))) { log('get_ticket returned mismatched identity; ignored'); return }
       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
+      const belongsToSelf = taskBelongsToAgent(ticket, { id: selfAgentId, identifier })
       const key = `${projectId}:${ticketId}`
       if (!belongsToSelf) {
         for (const [name, queue] of Object.entries(queues)) {
@@ -1519,10 +1699,47 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     }
   }
 
+  const mentionIntake = new Map()
   function onEvent(k, d) {
+    if (stopping) return
+    if (k !== 'agent:mention' && k !== 'channel:message') return trackOperation(routeEvent(k, d))
+    const cid = d?.channel_id ?? d?.channelId
+    const message = d?.message || {}
+    const parent = messageParentId(message)
+    const messageId = message.message_id ?? message.messageId ?? message.id
+    const malformedParent = parent == null && [message.parent_id, message.parentId, message.thread_id, message.threadId, message.reply_to, message.replyTo].some((value) => value != null)
+    if (malformedParent || !validBackendId(cid) || !validBackendId(messageId) || (parent != null && !validBackendId(parent))) { log('mention missing valid channel/message identity; ignored'); return }
+    const key = `${cid}:${parent ?? message.message_id ?? message.messageId ?? 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 () => {
+      try { await ensureSelfAgent() }
+      catch (error) { log('agent identity lookup unavailable; using configured aliases: ' + (error?.message || error)) }
+      if (k === 'channel:message' && selfOrganizationId == null) return { status: 'ignored-unknown-organization' }
+      // Organization fanout includes our own posts. Ignore stable self identity
+      // before recipient checks, replay guards or thread cancellation run.
+      if (messageSenderIsSelf(message, { id: selfAgentId, identifier })) return { status: 'ignored-self' }
+      const preliminary = classifyConversationTarget(message, [...selfAliases])
+      const irrelevant = preliminary.action === 'ignore' && preliminary.reason !== 'unaddressed-thread-activity'
+      let rootContent = ''
+      if (parent != null && !irrelevant && preliminary.action !== 'stand_down') {
+        try { rootContent = await resolveOwnThread(cid, parent) }
+        catch (error) {
+          if (!preliminary.explicitSelf && !memory.has(threadControlKey(cid, parent), 'active')) throw error
+          log('optional root context unavailable; preserving verified recipient: ' + (error?.message || error))
+        }
+      }
+      if (!stopping) return routeEvent('agent:mention', { ...d, _threadRootContent: rootContent })
+    }).catch((error) => { log('mention thread verification failed: ' + (error?.message || error)); return { status: 'retry' } })
+      .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)
+      return handleTaskSignal(k, raw)
     } else if (k === 'agent:mention') {
       const cid = raw.channel_id != null ? raw.channel_id : (raw.channelId != null ? raw.channelId : null)
       const msg = raw.message && typeof raw.message === 'object' ? raw.message : {}
@@ -1530,8 +1747,8 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
       const who = senderName(msg)
       // Reply IN THE SAME THREAD: parent is the thread root (the message's own id
       // for a top-level mention, or its parent when the mention is itself a reply).
-      const mid = msg.id != null ? msg.id : (msg.message_id != null ? msg.message_id : null)
-      const parent = msg.parent_id != null ? msg.parent_id : (msg.parentId != null ? msg.parentId : null)
+      const mid = msg.message_id ?? msg.messageId ?? msg.id ?? null
+      const parent = messageParentId(msg)
       const threadRoot = parent != null ? parent : mid
       const controlKey = threadControlKey(cid, threadRoot)
       const threadOwned = !!controlKey && memory.has(controlKey, 'active')
@@ -1629,13 +1846,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
@@ -1651,16 +1869,16 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
   }
 
   // The WebSocket drives real-time reactions (task:created/updated assigned to us,
-  // agent:mention). A thread reply that @mentions the agent fires agent:mention and
-  // is handled in-thread above. In addition we run a DAILY (and on-startup) sweep
-  // so anything assigned while the agent was offline — tasks especially — is still
-  // picked up even though we don't hot-poll.
+  // agent:mention and channel:message). Verified organization subscriptions
+  // recover channel mentions even when the backend omits targeted dispatch.
+  // Both event types share recipient, ownership and deduplication guards.
   log('up — backend WS watcher on ' + wsUrl + (canCode ? ' [code: ' + workdir + ']' : ''))
-  handle = connectAgentWs({ wsUrl, apiKey, identifier, onEvent, onConnect: () => { setTimeout(() => void reconcileBacklog(), 250) }, log })
+  handle = (dependencies.connect || connectAgentWs)({ wsUrl, apiKey, identifier, onEvent, onConnect: () => { if (autoStart) setTimeout(() => { if (!stopping) void reconcileBacklog() }, 250) }, log })
 
   let authorizationProbeBusy = false
   const legacyAuthorizationChecks = new Set()
   const resumeReadyAuthorizations = async () => {
+    if (stopping) return
     if (authorizationProbeBusy || (!blockedTasks.size && !failedTaskVersions.size)) return
     authorizationProbeBusy = true
     try {
@@ -1689,18 +1907,22 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     } catch (error) { log('Authorization resume failed: ' + (error?.message || error)) }
     finally { authorizationProbeBusy = false }
   }
-  const authorizationTimer = setInterval(() => void resumeReadyAuthorizations(), 2_000)
-  authorizationTimer.unref?.()
+  const deliveryTimer = autoStart ? setInterval(() => void flushPendingReplies(), 30_000) : null
+  deliveryTimer?.unref?.()
+  const authorizationTimer = autoStart ? setInterval(() => void resumeReadyAuthorizations(), 2_000) : null
+  authorizationTimer?.unref?.()
+  const heartbeatTimer = autoStart ? setInterval(() => emit('watcher.heartbeat', { status: 'running', active: queues.work.activeSize + queues.reply.activeSize, pending: queues.work.size + queues.reply.size, model: codeModel, chatModel: liteModel, workdir: workdir || '' }), 15_000) : null
+  heartbeatTimer?.unref?.()
   let introTimer = null, taskProbeStartTimer = null, taskProbeTimer = null
-  if (mcpConfig || mcpUrl) {
+  if (autoStart && (mcpConfig || mcpUrl)) {
     // Workspace ethics: a one-time hello the FIRST time this agent ever connects.
-    const introMarker = join(OV_DIR, 'intro-' + slugify(identifier) + '.done')
+    const introMarker = join(stateDir, 'intro-' + slugify(identifier) + '.done')
     if (!existsSync(introMarker)) {
       log('first connection — introducing self to the workspace')
       introTimer = setTimeout(() => {
         void announceIntroduction().then((delivered) => {
           if (!delivered) return
-          try { mkdirSync(OV_DIR, { recursive: true }); writeFileSync(introMarker, new Date().toISOString() + '\n') } catch { /* best-effort */ }
+          try { mkdirSync(stateDir, { recursive: true }); writeFileSync(introMarker, new Date().toISOString() + '\n') } catch { /* best-effort */ }
         }).catch((e) => log('guarded introduction failed: ' + (e?.message || e)))
       }, 5000) // let the socket subscribe first
     }
@@ -1713,32 +1935,42 @@ function loopBackendWs({ backend, wsUrl, apiKey, identifier, slug, claude, agent
     log('no MCP config — skipping intro + daily sweep (agent has no tools to post/act)')
   }
 
-  return new Promise(() => {
-    // Run until killed. Tidy up the socket + timers on termination so a restarting
-    // service doesn't leak a half-open connection or a dangling interval.
-    let stopping = false
-    const bye = async () => {
-      if (stopping) return
-      stopping = true
+  let resolveDone
+  const done = new Promise((resolve) => { resolveDone = resolve })
+  let closePromise
+  const close = () => {
+    if (closePromise) return closePromise
+    stopping = true
+    closePromise = (async () => {
       clearInterval(authorizationTimer)
+      clearInterval(deliveryTimer)
+      clearInterval(heartbeatTimer)
       if (introTimer) clearTimeout(introTimer)
       if (taskProbeStartTimer) clearTimeout(taskProbeStartTimer)
       if (taskProbeTimer) clearInterval(taskProbeTimer)
-      try { handle && handle.close() } catch { /* noop */ }
+      try { handle?.close() } catch { /* already disconnected */ }
       for (const queue of Object.values(queues)) {
-        queue.cancel(() => true, (item) => {
-          item.control.cancelled = true
-          void item.control.runner?.cancelCurrent?.()
-        })
+        queue.cancel(() => true, (item) => { item.control.cancelled = true })
       }
-      await Promise.all([...activeReplyRunners, ...activeWorkRunners].map((runner) => runner.cancelCurrent?.()))
+      await Promise.allSettled([...activeReplyRunners, ...activeWorkRunners].map((runner) => Promise.resolve().then(() => runner.cancelCurrent?.())))
+      await Promise.allSettled([...mentionIntake.values(), ...Object.values(queues).map((queue) => queue.settled()), ...messageDeliveries.values(), ...pendingOperations])
       workRunners.close()
       replyRunners.close()
-      process.exit(0)
-    }
-    process.on('SIGTERM', bye)
-    process.on('SIGINT', bye)
-  })
+      try { await memory.settled?.() }
+      catch (error) { log('memory shutdown failed: ' + (error?.message || error)) }
+      finally {
+        emit('watcher.stopped', { status: 'stopped' })
+        await journal.close()
+        resolveDone()
+      }
+    })()
+    return closePromise
+  }
+  return {
+    done, close, receive: onEvent, reconcile: () => stopping ? Promise.resolve() : trackOperation(reconcileBacklog()),
+    resumeAuthorizations: resumeReadyAuthorizations, retryDeliveries: flushPendingReplies,
+    get pending() { return queues.work.size + queues.reply.size + mentionIntake.size },
+  }
 }
 
 // ── the warm loop ────────────────────────────────────────────────────────────
@@ -1746,16 +1978,55 @@ function loop({ host, key, slug, claude, agent, mcpConfig, mcpUrl, workdir, mode
   const log = (m) => process.stdout.write('[warm ' + new Date().toISOString() + '] ' + m + '\n')
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
   const canCode = !!workdir
+  const journal = runtimeJournal({ stateDir: OV_DIR, agent: { identifier: slug, slug, provider: agent }, secrets: [key] })
+  const emit = (type, data = {}) => journal.emit(type, { watcherPid: process.pid, source: 'relay', ...data })
+  let stopping = false, cycleSequence = 0, activeCycle = null
+  let introTimer, sweepTimer, closePromise
+  emit('watcher.started', { status: 'running', model, chatModel, workdir: workdir || '' })
   // Static charter as the cached system prompt (this loop's MCP authenticates via a
   // Bearer header, so no per-call creds are needed in the prompt).
   const systemPrompt = canCode ? CODE_CHARTER : CHAT_CHARTER
-  const { runCycle } = createCycleRunner({ claude, agent, mcpUrl, mcpHeaders: { Authorization: 'Bearer ' + key }, cfgKey: slug, mcpConfig, workdir, log, debug, model, systemPrompt })
+  const runner = createCycleRunner({ claude, agent, mcpUrl, mcpHeaders: { Authorization: 'Bearer ' + key }, cfgKey: slug, mcpConfig, workdir, log, debug, model, systemPrompt, onEvent: emit })
+  const runCycle = (prompt, selectedModel) => {
+    if (stopping) return Promise.resolve({ subtype: 'canceled' })
+    const cycleId = `${journal.runId}:cycle:${++cycleSequence}`
+    const kind = prompt === fullPrompt ? 'full' : prompt === fastPrompt ? 'fast' : 'sweep'
+    const metadata = { cycleId, kind, lane: canCode && kind === 'full' ? 'work' : 'reply', model: selectedModel, workdir: workdir || '' }
+    const startedAt = performance.now()
+    emit('cycle.queued', { ...metadata, status: 'queued' })
+    emit('cycle.started', { ...metadata, status: 'running', queueMs: 0 })
+    let status = 'error'
+    activeCycle = Promise.resolve().then(() => stopping ? { subtype: 'canceled' } : runner.runCycle(prompt, selectedModel, { cycleId })).then((result) => { status = result?.subtype || 'ok'; return result }).finally(() => {
+      emit(status === 'canceled' ? 'cycle.cancelled' : 'cycle.finished', { ...metadata, status, durationMs: Math.round(performance.now() - startedAt) })
+      activeCycle = null
+    })
+    return activeCycle
+  }
   const fullPrompt = canCode ? CODE_FULL : CYCLE
   const fastPrompt = canCode ? CODE_FAST : CYCLE_FAST
   const liteModel = chatModel || model // cheaper model for chat/quick cycles
 
   const seen = new Set()
   let busy = false
+  const heartbeatTimer = setInterval(() => emit('watcher.heartbeat', { status: 'running', active: busy ? 1 : 0, model, chatModel, workdir: workdir || '' }), 15_000)
+  heartbeatTimer.unref?.()
+  const close = () => {
+    if (closePromise) return closePromise
+    stopping = true
+    clearInterval(heartbeatTimer)
+    clearTimeout(introTimer)
+    clearInterval(sweepTimer)
+    closePromise = (async () => {
+      await Promise.allSettled([Promise.resolve().then(() => runner.cancelCurrent?.()), activeCycle])
+      try { runner.close?.() } catch { /* already closed */ }
+      emit('watcher.stopped', { status: 'stopped' })
+      await journal.close()
+    })()
+    return closePromise
+  }
+  const stop = () => void close().then(() => process.exit(0))
+  process.once('SIGTERM', stop)
+  process.once('SIGINT', stop)
   let firstCheck = true
   let lastNewAt = Date.now()
   // A one-off prompt (intro / daily sweep) the main loop runs the next time it's
@@ -1766,11 +2037,11 @@ function loop({ host, key, slug, claude, agent, mcpConfig, mcpUrl, workdir, mode
     if (!existsSync(introMarker)) {
       try { mkdirSync(OV_DIR, { recursive: true }); writeFileSync(introMarker, new Date().toISOString() + '\n') } catch { /* best-effort */ }
       log('first run — introducing self to the workspace')
-      setTimeout(() => { queuedSpecial = INTRO }, 5000)
+      introTimer = setTimeout(() => { queuedSpecial = INTRO }, 5000)
     }
     // The first inbox response below decides whether a startup sweep is needed.
     // Do not spend a model turn on every service restart when the inbox is empty.
-    setInterval(() => { log('daily catch-up sweep'); queuedSpecial = SWEEP + '\n\n' + COORDINATE }, 24 * 60 * 60 * 1000)
+    sweepTimer = setInterval(() => { log('daily catch-up sweep'); queuedSpecial = SWEEP + '\n\n' + COORDINATE }, 24 * 60 * 60 * 1000)
   }
 
   async function check() {
@@ -1788,7 +2059,7 @@ function loop({ host, key, slug, claude, agent, mcpConfig, mcpUrl, workdir, mode
 
   async function run() {
     log('up — warm watcher on ' + host + (canCode ? ' [code: ' + workdir + ']' : ''))
-    for (;;) {
+    while (!stopping) {
       let delay = FAST
       try {
         // Run a queued one-off (intro / daily sweep) first when free, on the same
@@ -1801,6 +2072,7 @@ function loop({ host, key, slug, claude, agent, mcpConfig, mcpUrl, workdir, mode
           continue
         }
         const res = busy ? { items: [], paused: false } : await check()
+        if (stopping) break
         const items = Array.isArray(res.items) ? res.items : []
         if (firstCheck && Array.isArray(res.items)) {
           firstCheck = false
@@ -1844,7 +2116,7 @@ function loop({ host, key, slug, claude, agent, mcpConfig, mcpUrl, workdir, mode
     }
   }
 
-  return run()
+  return run().finally(close)
 }
 
 // ── background service install (launchd / systemd) ───────────────────────────