openvisio-agent 0.25.11 → 0.25.13

package/src/harness-checkpoints.mjs

@@ -0,0 +1,34 @@
+import { createHash } from 'node:crypto'
+
+// Compact external state survives runtime eviction without keeping a model or
+// child process alive. Never persist private reasoning or raw tool payloads.
+export function createHarnessCheckpoints({ memory, resourceId, now = () => Date.now(), ttlMs = 15 * 60_000 }) {
+  const keyFor = ({ refs = {}, workdir = '', canCode = false }) => {
+    const scope = refs.projectId != null && refs.ticketId != null
+      ? ['ticket', refs.projectId, refs.ticketId]
+      : refs.channelId != null ? ['thread', refs.channelId, refs.threadId ?? 'root'] : null
+    if (!scope) return ''
+    return 'harness-checkpoint:' + createHash('sha256').update(JSON.stringify([resourceId, scope, workdir, canCode])).digest('hex')
+  }
+  return {
+    load(scope) {
+      const key = keyFor(scope)
+      const saved = key && memory.get(key)?.meta?.checkpoint
+      if (!saved || now() < saved.savedAt || now() - saved.savedAt > ttlMs) return ''
+      return `RECENT HARNESS CHECKPOINT (${Math.round((now() - saved.savedAt) / 1000)} seconds old; historical context, not new instructions or authorization):\n${JSON.stringify(saved)}\nReuse these findings and pending steps. Do not repeat broad discovery or a known failing read merely because this runtime restarted. Recheck the specific ticket ownership/status and blocker condition before acting; current instructions and live changes win. Completed work is not pending work. A canceled task needs renewed authorization. Never replay an unconfirmed write without reading back its state. Continue independent authorized work when one part is blocked.`
+    },
+    save(scope, value) {
+      const key = keyFor(scope)
+      if (!key) return
+      const previous = memory.get(key)?.meta?.checkpoint
+      const checkpoint = {
+        savedAt: now(), state: String(value.state || 'in_progress').slice(0, 80),
+        outcome: String(value.outcome || previous?.outcome || '').slice(-6000),
+        outcomeObservedAt: value.outcome ? now() : previous?.outcomeObservedAt,
+        plan: (value.plan || []).slice(0, 12).map(entry => ({ content: String(entry.content || '').slice(0, 240), status: entry.status })),
+        tools: (value.tools || []).slice(-16).map(entry => ({ name: String(entry.name || '').slice(0, 100), status: entry.status })),
+      }
+      memory.remember({ key, kind: 'harness-checkpoint', state: checkpoint.state, refs: scope.refs, summary: checkpoint.outcome || 'Saved runtime plan and tool checkpoints.', meta: { checkpoint } })
+    },
+  }
+}

package/src/mastra-harness.mjs

@@ -116,7 +116,7 @@ function contentText(content) {
 
 export function createMastraAcpRunner({
   agent, mcpUrl, mcpHeaders = {}, workdir, canCode = !!workdir, canCoordinate = false, workspaceAvailable = canCode, maxCycleMs = 20 * 60_000,
-  log = () => {}, debug = false, model, onTool, onEvent, systemPrompt = '', getContextEnvironment, AcpAgentClass = AcpAgent,
+  log = () => {}, debug = false, model, onTool, onEvent, systemPrompt = '', getContextEnvironment, checkpoints, AcpAgentClass = AcpAgent,
 }) {
   const runtime = acpRuntimeCommand(agent)
   if (!runtime) return null
@@ -150,7 +150,7 @@ export function createMastraAcpRunner({
     let timedOut = false
     const startedAt = performance.now()
     const cycleId = cycleOptions.cycleId ?? null
-    const emit = (type, data = {}) => notify(type, { cycleId, attempt: cycleOptions.attempt || 1, provider: agent, runtime: 'mastra-acp', workdir: cycleCwd, watcherPid: process.pid, runtimePid: null, ...data })
+    const emit = (type, data = {}) => notify(type, { cycleId, attempt: cycleOptions.attempt || 1, provider: agent, runtime: 'mastra-acp', lane: canCode ? 'work' : 'reply', workdir: cycleCwd, watcherPid: process.pid, runtimePid: null, ...data })
     const progress = new Map()
     const flushProgress = () => {
       for (const [messageId, entry] of progress) {
@@ -179,6 +179,18 @@ export function createMastraAcpRunner({
     const tools = new Map()
     let toolSequence = 0
     let outputText = ''
+    let currentPlan = []
+    let checkpointState = 'in_progress'
+    let lastCheckpointAt = 0
+    const checkpointScope = { refs: cycleOptions.contextRefs, workdir: cycleCwd, canCode }
+    const saveCheckpoint = (force = false) => {
+      if (!checkpoints || (!force && Date.now() - lastCheckpointAt < 15_000)) return
+      lastCheckpointAt = Date.now()
+      try {
+        checkpoints.save(checkpointScope, { state: checkpointState, outcome: redact(outputText), plan: currentPlan,
+          tools: [...tools.values()].map(tool => ({ name: redact(toolName(tool) || clean(tool.title, 100)), status: tool.status })) })
+      } catch { /* checkpoint storage cannot interrupt work */ }
+    }
     let didCode = false
     let didRepoMutation = false
     let didMessage = false
@@ -203,7 +215,7 @@ export function createMastraAcpRunner({
           ...Object.entries(contextEnvironment).map(([name, value]) => ({ name, value: String(value) })),
       ],
     }] : [{ type: 'http', name: 'openvisio-team', url: mcpUrl, headers }]
-    const sessionKey = JSON.stringify([cycleCwd, disabledMcpTools, mcpServers])
+    const sessionKey = JSON.stringify([cycleCwd, cycleOptions.contextRefs, disabledMcpTools, mcpServers])
     if (!persistent || persistentKey !== sessionKey) {
       if (persistent) disconnect(persistent)
       const sessionToken = {}
@@ -327,7 +339,12 @@ export function createMastraAcpRunner({
         }
       }
       log(`running ${agent} cycle via Mastra ACP…${selectedModel || requestedModel ? ` [${selectedModel || requestedModel}]` : ' [runtime default]'}`)
-      const fullPrompt = systemPrompt && !sessionHasPrompted ? `${systemPrompt}\n\n${prompt}` : prompt
+      let restored = ''
+      if (!sessionHasPrompted) {
+        try { restored = checkpoints?.load(checkpointScope) || '' } catch { /* optional recall */ }
+      }
+      const fullPrompt = [!sessionHasPrompted ? systemPrompt : '', restored, prompt].filter(Boolean).join('\n\n')
+      if (restored) emit('context.restored', { source: 'harness-checkpoint', chars: restored.length })
       sessionHasPrompted = true
       const stream = acp.connection.promptStream(fullPrompt, controller.signal)[Symbol.asyncIterator]()
       let readyReported = false
@@ -350,6 +367,8 @@ export function createMastraAcpRunner({
             priority: ['low', 'medium', 'high'].includes(entry?.priority) ? entry.priority : undefined,
           })).filter((entry) => entry.content)
           emit('plan.updated', { entries })
+          currentPlan = entries
+          saveCheckpoint()
           continue
         }
         if (update.sessionUpdate === 'agent_message_chunk') {
@@ -364,6 +383,7 @@ export function createMastraAcpRunner({
         const order = prior.status === 'completed' && (!update.status || update.status === 'completed') ? prior.order : ++toolSequence
         const merged = { ...prior, ...update, order }
         tools.set(update.toolCallId, merged)
+        if (['completed', 'failed'].includes(merged.status)) saveCheckpoint()
         const name = toolName(merged)
         const label = name || clean(merged.title, 100) || 'tool'
         const terminal = ['completed', 'failed'].includes(merged.status)
@@ -386,11 +406,15 @@ export function createMastraAcpRunner({
       // Only final, completed tool states are evidence. Started/failed edits and
       // board mutations cannot stand in for completed repository work.
       let workRequest = null
+      let completedHandoff = false
       for (const tool of [...tools.values()].sort((a, b) => a.order - b.order)) {
         const name = toolName(tool)
         if (tool.status === 'failed') policyBlock ||= codexPolicyBlock(json(tool.rawOutput))
         if (tool.status !== 'completed') continue
-        if (name === WORK_SESSION_TOOL) workRequest = workSessionRequest(tool.rawOutput ?? tool.content) || workRequest
+        if (name === WORK_SESSION_TOOL && !canCode && workspaceAvailable) {
+          completedHandoff = true
+          workRequest = workSessionRequest(tool.rawOutput) || workSessionRequest(tool.content) || workRequest
+        }
         didMessage ||= ['post_message', 'create_task_comment', 'comment_ticket'].includes(name)
         didChannelMessage ||= name === 'post_message'
         didResultMessage ||= name === 'post_message' && didRepoMutation
@@ -409,10 +433,16 @@ export function createMastraAcpRunner({
       if (beforeState != null && after != null && beforeState !== after) { didCode = true; didRepoMutation = true }
       for (const [name, detail] of errors) log(`MCP ${name} failed: ${redact(detail)}`)
       log(`${agent} cycle done via Mastra ACP (${errors.size ? 'tool-errors' : 'ok'})`)
+      const handoffError = completedHandoff && !workRequest
+      const resultStatus = policyBlock ? 'blocked' : handoffError ? 'handoff_error' : 'ok'
+      checkpointState = policyBlock ? 'blocked' : handoffError ? 'handoff_error' : 'ended'
+      if (handoffError) emit('process.error', { status: 'handoff_error', summary: 'The work-session tool completed but its continuation could not be decoded. No coding session was started.' })
       flushProgress()
-      if (outputText.trim()) emit('output.final', { text: redact(outputText.trim()).slice(0, 8000), status: policyBlock ? 'blocked' : 'ok' })
+      // A handoff is a request to queue work, not a completed task or proof that
+      // the coding process has started. The watcher owns its public delivery.
+      if (outputText.trim() && !workRequest && !handoffError) emit('output.final', { text: redact(outputText.trim()).slice(0, 8000), status: resultStatus })
       return {
-        type: 'result', subtype: policyBlock ? 'blocked' : 'ok', stopReason: 'end_turn', workRequest, policyBlock, timings: { firstEventMs, totalMs: Math.round(performance.now() - startedAt) }, runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),
+        type: 'result', subtype: resultStatus, stopReason: 'end_turn', workRequest, policyBlock, timings: { firstEventMs, totalMs: Math.round(performance.now() - startedAt) }, runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),
         mcpCalls: [...calls], mcpErrors: [...errors.keys()], mcpErrorDetails: Object.fromEntries(errors),
         didCode, didRepoMutation, didMessage, didChannelMessage, didResultMessage,
         didMcpTaskRead, didMcpTaskUpdate,
@@ -424,6 +454,7 @@ export function createMastraAcpRunner({
       }
       const canceled = controller.signal.aborted
       const subtype = providerFailure?.subtype || (timedOut ? 'timeout' : canceled ? 'canceled' : 'error')
+      checkpointState = subtype
       const errorDetail = [error?.message, error?.data ? json(error.data) : ''].filter(Boolean).join(': ')
       const safeError = redact(errorDetail)
       flushProgress()
@@ -438,6 +469,7 @@ export function createMastraAcpRunner({
         didMcpTaskRead, didMcpTaskUpdate,
       }
     } finally {
+      saveCheckpoint(true)
       flushProgress()
       if (!disconnected.has(acp)) emit('process.ready', { status: 'idle', sessionId: acp.connection.sessionId || null })
       clearTimeout(timer)

package/src/peer-turns.mjs

@@ -0,0 +1,14 @@
+import { createHash } from 'node:crypto'
+
+// Three concrete peer requests per human turn. Reserve at intake, not delivery:
+// concurrent messages cannot spend the same budget. Persist with the ledger.
+export function admitPeerTurn(previous, text, target) {
+  if (target.action !== 'handle') return null
+  const normalized = String(text).replace(/\s+/g, ' ').trim().toLowerCase()
+  const fingerprint = createHash('sha256').update(normalized).digest('hex')
+  const prior = previous?.state === 'human' ? [] : previous?.meta?.requests ?? (previous?.state === 'replied' ? ['legacy-reply'] : [])
+  if (prior.length >= 3 || prior.includes(fingerprint)) return null
+  if (prior.length && (!target.explicitSelf || !/\b(?:review|check|confirm|explain|investigate|fix|implement|share|send|compare|verify)\b/i.test(normalized))) return null
+  if (/^@[\w -]+[,!:]?\s+(?:thanks|thank you|got it|acknowledged|understood)[.!\s]*$/i.test(normalized)) return null
+  return { requests: [...prior, fingerprint] }
+}

package/src/runtime-control.mjs

@@ -40,7 +40,7 @@ export function workSessionRequest(output, depth = 0) {
     ...(typeof request.acknowledgement === 'string' && request.acknowledgement.trim() && request.acknowledgement.length <= 1200 ? { acknowledgement: request.acknowledgement.trim() } : {}),
     ...(validPlan(request.plan) ? { plan: request.plan.map(step => step.trim()) } : {}),
   }
-  for (const key of ['content', 'text', 'result', 'structuredContent']) {
+  for (const key of ['output', 'content', 'text', 'result', 'structuredContent']) {
     const nested = workSessionRequest(output[key], depth + 1)
     if (nested) return nested
   }

package/src/thread-context.mjs

@@ -26,7 +26,7 @@ function containsRoot(value, rootId, identity, depth = 0) {
   if (Array.isArray(value)) return value.some((row) => containsRoot(row, rootId, identity, depth + 1))
   if (typeof value !== 'object') return false
   if (String(value.message_id ?? value.messageId ?? value.id) === String(rootId) && messageParentId(value) == null && typeof (value.content ?? value.body ?? value.text) === 'string' && verifiedOtherAuthor(value, identity)) return true
-  return ['messages', 'replies', 'items', 'data', 'result', 'thread', 'message', 'root'].some((key) => containsRoot(value[key], rootId, identity, depth + 1))
+  return ['messages', 'replies', 'items', 'body', 'data', 'result', 'thread', 'message', 'root'].some((key) => containsRoot(value[key], rootId, identity, depth + 1))
 }
 
 export function createThreadContextResolver({ read, save, cancelled, load, identity, now = Date.now }) {

package/src/watch.mjs

@@ -13,8 +13,10 @@ import { connectAgentWs, assertWebSocket } from './ws.mjs'
 import { buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, conversationAsksPendingTickets, conversationCreatesTicket, conversationNeedsCode, conversationRequestsChannelMessage, failedTaskRevisionIsCurrent, mentionDedupeKeys, messageParentId, messageSenderIsAgent, messageSenderIsSelf, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskAgentIdentifier, taskBelongsToAgent, taskCommentFromEvent, taskEventSenderIsSelf, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
 import { WORK_SESSION_TOOL, workSessionRequest, agentProfileContext } from './runtime-control.mjs'
 import { createMastraMemory } from './memory.mjs'
+import { createHarnessCheckpoints } from './harness-checkpoints.mjs'
 import { createContextService } from './context-service.mjs'
 import { contextToolGuide } from './context-tools.mjs'
+import { loadProjectTickets, needsWorkContinuation } from './work-recovery.mjs'
 import { toolWithoutCredentialInputs } from './codex-mcp-proxy.mjs'
 import { compactAgentMessage } from './tool-policy.mjs'
 import { repositoryHasPrPushAuthorization, configurePrPublishing } from './pr-push.mjs'
@@ -28,6 +30,8 @@ import { releaseAuthorizedPause } from './authorization-resume.mjs'
 import { dedicatedChannel, repliesAfterSource } from './channel-routing.mjs'
 import { createTaskTypeLookup, loadProjectTaskTypes } from './task-types.mjs'
 import { createThreadContextResolver } from './thread-context.mjs'
+import { compileConversationContext, createConversationReader, conversationAuthor, checkedConversationResult } from './conversation-context.mjs'
+import { admitPeerTurn } from './peer-turns.mjs'
 import { assignmentRequest, assignmentStatusOnly, routeAssignments } from './assignment-routing.mjs'
 import { modelProcessOptions, stopModelProcess } from './process-lifecycle.mjs'
 import { createMastraAcpRunner } from './mastra-harness.mjs'
@@ -343,13 +347,13 @@ export async function runWatch({ flags }) {
 }
 
 // Claude keeps its native stream; every ACP provider uses the same Mastra harness.
-export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model, onTool, onEvent, systemPrompt, getContextEnvironment, canCoordinate = false, workspaceAvailable = !!workdir }) {
+export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model, onTool, onEvent, systemPrompt, getContextEnvironment, checkpoints, canCoordinate = false, workspaceAvailable = !!workdir }) {
   const canCode = !!workdir
   const maxCycleMs = canCode ? MAX_CODE_CYCLE_MS : MAX_CYCLE_MS
   // ACP providers run through Mastra's shared 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, workspaceAvailable, maxCycleMs, log, debug, model, onTool, onEvent, systemPrompt, getContextEnvironment })
+  const mastraRunner = createMastraAcpRunner({ agent, mcpUrl, mcpHeaders, workdir, canCode, canCoordinate, workspaceAvailable, maxCycleMs, log, debug, model, onTool, onEvent, systemPrompt, getContextEnvironment, checkpoints })
   if (mastraRunner) return mastraRunner
   let child = null
   let privateMcpDir = ''
@@ -658,6 +662,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     claude, agent, mcpUrl, mcpHeaders: { 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier },
     cfgKey: identifier, mcpConfig, workdir, workspaceAvailable: canCode, log, debug, model, systemPrompt, onEvent: runtimeEvent,
     getContextEnvironment: () => contextService.environment(),
+    checkpoints: { load: scope => harnessCheckpoints.load(scope), save: (scope, value) => harnessCheckpoints.save(scope, value) },
   }
   // One watcher and one WS subscription, with a bounded pool of isolated coding
   // runtimes. Replies serialize within a thread while independent threads run
@@ -784,6 +789,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     resourceId: identifier,
   })
   const contextBackend = new URL(backend || mcpUrl || 'http://local.invalid')
+  const harnessCheckpoints = createHarnessCheckpoints({ memory, resourceId: `${contextBackend.origin}${contextBackend.pathname.replace(/\/$/, '')}:${identifier}` })
   const contextService = dependencies.contextService || createContextService({
     directory: stateDir, resourceId: `${contextBackend.origin}${contextBackend.pathname.replace(/\/$/, '')}:${identifier}`,
     loadTasks: () => loadPendingTickets(),
@@ -1005,6 +1011,21 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     }).finally(() => { mcpToolDiscoveryPromise = null })
     return mcpToolDiscoveryPromise
   }
+  const conversationReader = createConversationReader({ load: async (scope) => {
+    const names = await discoverMcpTools()
+    const ticket = scope.ticketId != null
+    const tool = ticket ? 'list_task_comment_thread' : 'list_message_thread'
+    if (!names.has(tool)) throw new Error('Conversation thread tool not advertised')
+    const args = ticket ? { project_id: scope.projectId, ticket_id: scope.ticketId, comment_id: scope.threadId }
+      : { channel_id: scope.channelId, message_id: scope.threadId }
+    const [thread, surroundings] = await Promise.all([
+      callMcpTool(tool, args).then(checkedConversationResult),
+      !ticket && names.has('list_channel_messages')
+        ? callMcpTool('list_channel_messages', { channel_id: scope.channelId, limit: 12, before_id: scope.threadId }).then(checkedConversationResult).catch(() => null)
+        : null,
+    ])
+    return { thread, surroundings }
+  } })
   const callOptionalTicketComment = async ({ projectId, ticketId, content, parentId }) => {
     let names
     try { names = await discoverMcpTools() }
@@ -1055,10 +1076,10 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const projects = Array.isArray(projectsData.projects) ? projectsData.projects : []
     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 }),
+        loadProjectTickets({ projectId: project.id, read: async (name, args) => toolData(await callMcpReadWithRetry(name, args), name), listTools: () => mcpClient.listTools(), matches: resolveTaskOwner }),
         taskTypeSets(project.id),
       ])
-      const tasksData = toolData(tasksResult, 'list_tasks')
+      const tasksData = { tasks: tasksResult }
       const { done: doneIds, review: reviewIds } = typesResult
       const tasks = await mapConcurrent(Array.isArray(tasksData.tasks) ? tasksData.tasks : [], 3, async (task) => {
         await resolveTaskOwner(task)
@@ -1162,7 +1183,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     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) })),
+    load: async (cid, root) => (await conversationReader.read({ channelId: Number(cid), threadId: Number(root) })).thread,
   })
   const peerTurnKey = (surface, ...parts) => `peer-turn:${surface}:${parts.map((value) => String(value ?? '?')).join(':')}`
   const ownTaskCommentKey = (projectId, ticketId, content) => {
@@ -1170,7 +1191,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     return `own-task-comment:${projectId}:${ticketId}:${normalized.length}:${normalized.slice(0, 120)}:${normalized.slice(-120)}`
   }
   const rememberPeerReply = (key, refs = {}) => {
-    if (key) memory.remember({ key, kind: 'peer-turn', state: 'replied', summary: 'Replied once to a peer agent; waiting for a human turn.', refs })
+    if (key) memory.remember({ key, kind: 'peer-turn', state: 'replied', summary: 'Replied to a peer; bounded concrete follow-ups remain available.', refs, meta: memory.get(key)?.meta })
   }
   const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', sourceMessageId, allowCancelled = false, peerLoopKey = '', isCancelled = () => false }) => {
     if (stopping) throw new Error('Watcher is stopping')
@@ -1190,6 +1211,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const controlKey = threadControlKey(channelId, parentId)
     const suppressCancelled = () => {
       if (isCancelled()) return { posted: false, reason: 'cycle-cancelled' }
+      if (sourceMessageId != null && memory.has(`deleted-message:${channelId}:${sourceMessageId}`, 'deleted')) return { posted: false, reason: 'source-deleted' }
       if (memory.has(deliveryKey, 'suppressed')) return { posted: false, reason: 'source-cancelled' }
       if (allowCancelled || !controlKey || !memory.has(controlKey, 'cancelled')) return null
       pendingReplyDeliveries.delete(deliveryKey)
@@ -1208,7 +1230,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     }
     const run = (async () => {
       if (parentId != null) {
-        const live = toolData(await callMcpTool('list_message_thread', { channel_id: Number(channelId), message_id: Number(parentId) }))
+        const live = checkedConversationResult(await callMcpTool('list_message_thread', { channel_id: Number(channelId), message_id: Number(parentId) }))
         const plans = skipIfAnyAgentReply ? memory.recall({ channelId: Number(channelId), threadId: Number(parentId) }, 1000).filter(node => node.kind === 'work-plan' && node.meta?.sourceKey === sourceKey) : []
         const rendered = repliesAfterSource(renderedAgentMessages(live, { id: selfAgentId, identifier, slug, name: slug }), sourceMessageId).filter(row => !plans.some(plan => normalizeRenderedMessageText(plan.summary) === normalizeRenderedMessageText(row.content)))
         const duplicate = rendered.some((row) => normalizeRenderedMessageText(row.content) === normalizeRenderedMessageText(message))
@@ -1514,7 +1536,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         try {
           const assigned = []
           const [tasksData, typesData] = await Promise.all([
-            callMcpTool('list_tasks', { project_id: project.id }).then((result) => toolData(result, 'list_tasks')),
+            loadProjectTickets({ projectId: project.id, read: async (name, args) => toolData(await callMcpReadWithRetry(name, args), name), listTools: () => mcpClient.listTools(), matches: resolveTaskOwner }).then(tasks => ({ tasks })),
             taskTypeSets(project.id),
           ])
           const { done: doneIds, review: reviewIds } = typesData
@@ -1673,6 +1695,13 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         ? { channelId: delivery.channelId, threadId: delivery.parentId }
       : activeTaskRef ? { projectId: activeTaskRef.projectId, ticketId: activeTaskRef.ticketId } : {}
     let recalled = ''
+    runnerOptions.contextRefs = memoryRefs
+    if (delivery?.sourceMessage) {
+      let snapshot, unavailable = !!delivery.contextUnavailable
+      try { if (!unavailable) snapshot = await conversationReader.read(memoryRefs) }
+      catch (error) { unavailable = true; log('Compiled conversation history unavailable: ' + (error?.message || error)) }
+      ctx.push(compileConversationContext({ ...snapshot, source: delivery.sourceMessage, scope: memoryRefs, unavailable }))
+    }
     try { recalled = await memory.context(memoryRefs) }
     catch (error) { log('Optional history unavailable; agent can retrieve context with its tools: ' + (error?.message || error)) }
     const capabilityContext = kind !== 'full' && canCode
@@ -1708,7 +1737,17 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       cycleControl.planKey ||= 'plan:' + (delivery?.key || `${activeTaskRef?.projectId}:${activeTaskRef?.ticketId}:${verifiedTaskRevision}`)
       cycleControl.outcome = 'running'
       log(`cycle timing preflight=${Math.round(performance.now() - cycleStartedAt)}ms kind=${kind}`)
-      const result = await runner.runCycle(prompt, useModel, runnerOptions)
+      let result = await runner.runCycle(prompt, useModel, runnerOptions)
+      // Stay in the same writable session and delivery scope after a premature
+      // acknowledgment. Never escalate reply-only work or bypass cancellation.
+      const unfinishedTurn = value => needsWorkContinuation(value, { pendingPlan: cycleControl.planEntries?.some(entry => ['pending', 'in_progress'].includes(entry.status)) })
+      if (kind === 'full' && canCode && !cycleControl.cancelled && !stopping && unfinishedTurn(result)) {
+        await cycleControl.planDelivery
+        if (cycleControl.cancelled || stopping) return
+        emit('cycle.continued', { cycleId: cycleControl.cycleId, reason: 'acknowledgement without an outcome', status: 'continued' })
+        result = await runner.runCycle(`${prompt}\n\nCONTINUE THE ACCEPTED WORK: Your previous turn ended without a result: ${String(result.outputText || '(no final result)').slice(0, 700)}\nYour coding workspace is still available. An acknowledgement is not completion. Continue the original authorized task now, using alternate read tools if needed. Do not repeat the acknowledgement. Finish with a concrete result and verification, or a specific blocker with the checks attempted. Do not invent outcomes or bypass permissions.`, useModel, runnerOptions)
+        if (unfinishedTurn(result)) result = { ...result, subtype: 'incomplete', is_error: true }
+      }
       if (result?.model) {
         emit('models.applied', { requestedModel: useModel, model: result.model, tier: kind === 'full' ? 'coding' : 'reply', modelSettingsRevision: cycleModelRevision })
       }
@@ -1812,6 +1851,8 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   // Distill an event's WS payload into a directive the model can act on without
   // any extra lookup.
   const senderName = (m) => {
+    const attributed = conversationAuthor(m || {})
+    if (attributed.kind === 'agent' && attributed.name !== 'Unknown') return attributed.name
     const s = m && (m.taskSender || m.task_sender || m.sender || m.user || m.author || m.member || m.taskSenderAgent || m.task_sender_agent || m.senderAgent || m.sender_agent || m.agent)
     if (!s) return ''
     return (`${s.first_name || s.firstName || ''} ${s.last_name || s.lastName || ''}`.trim() || s.name || s.display_name || s.identifier || s.email || '')
@@ -1953,11 +1994,6 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     if (messageSenderIsSelf(comment, { id: selfAgentId, identifier, slug, name })) return { status: 'ignored-self' }
     const peer = messageSenderIsAgent(comment)
     const loopKey = peerTurnKey('task-comment', projectId, ticketId, rootCommentId)
-    if (peer && memory.has(loopKey, 'replied')) {
-      log(`task:comment project=${projectId} ticket=${ticketId} ignored after one peer-agent reply; waiting for a human turn`)
-      return { status: 'ignored-peer-loop' }
-    }
-    if (!peer) memory.remember({ key: loopKey, kind: 'peer-turn', state: 'human', summary: text, refs: { projectId: Number(projectId), ticketId: Number(ticketId), threadId: Number(rootCommentId) } })
     const target = classifyConversationTarget(comment, [...selfAliases], { threadOwned: true })
     if (target.action !== 'handle') {
       log('task:comment ignored before model start (' + target.reason + ')')
@@ -1979,6 +2015,12 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         log(`task:comment ticket #${ticketId} is not assigned to this agent — ignored`)
         return { status: 'ignored-unassigned' }
       }
+      if (peer) {
+        const meta = admitPeerTurn(memory.get(loopKey), text, target)
+        if (!meta) return { status: 'ignored-peer-loop' }
+        memory.remember({ key: loopKey, kind: 'peer-turn', state: 'reserved', meta })
+      } else memory.remember({ key: loopKey, kind: 'peer-turn', state: 'human' })
+      conversationReader.invalidate({ projectId: Number(projectId), ticketId: Number(ticketId), threadId: Number(rootCommentId) })
       const who = senderName(comment)
       const ticketSlug = ticketDisplaySlug(ticket)
       memory.remember({ key: sourceKey, kind: 'task-comment', state: 'received', summary: text, refs: { projectId: Number(projectId), ticketId: Number(ticketId), messageId: Number(commentId), threadId: Number(rootCommentId) } })
@@ -1991,6 +2033,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         sourceKey,
         watcherOwned: true,
         peerLoopKey: peer ? loopKey : '',
+        sourceMessage: { ...comment, id: Number(commentId) },
       }
       const label = ticketSlug || String(ticket.title || 'the assigned ticket')
       const context = `The watcher received a new comment on your assigned ticket ${JSON.stringify(label)} from ${JSON.stringify(who || (peer ? 'another agent' : 'a teammate'))}: ${JSON.stringify(text)}. Authoritative ticket details: ${JSON.stringify({ slug: ticketSlug, title: ticket.title, description: ticket.description, priority: ticket.priority, status: ticket.type?.name ?? ticket.task_type?.name ?? ticket.status ?? ticket.state })}. Answer the comment directly in the context of this ticket. Do not call post_message or any task-comment tool; return only the final reply and the watcher will post it once in the source comment thread.${peer ? ' This was authored by another team agent. Address its concrete question or request without replacing it with ticket inventory or adding an open-ended reciprocal question.' : ''}`
@@ -2011,7 +2054,12 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const messageCandidate = [outer.message, data.message, payload.message].find((item) => item && typeof item === 'object' && !Array.isArray(item))
     const directId = source.message_id ?? source.messageId ?? source.id
     const directContent = source.content ?? source.body ?? source.text ?? (typeof source.message === 'string' ? source.message : null)
-    const message = messageCandidate || (directId != null && directContent != null ? { ...source, content: directContent } : {})
+    let message = messageCandidate || (directId != null && directContent != null ? { ...source, content: directContent } : {})
+    const messageId = message.message_id ?? message.messageId ?? message.id
+    // The documented mention envelope may provide the root outside message.
+    // Explicit inner parent fields always win, including malformed ones.
+    if (!['parent_id', 'parentId', 'thread_id', 'threadId', 'reply_to', 'replyTo'].some((key) => message[key] != null)
+      && validBackendId(source.thread_root_id) && String(source.thread_root_id) !== String(messageId)) message = { ...message, parent_id: Number(source.thread_root_id) }
     const channelId = source.channel_id ?? source.channelId ?? source.channel?.id ?? message.channel_id ?? message.channelId ?? message.channel?.id
     return { ...source, channel_id: channelId, message }
   }
@@ -2019,6 +2067,31 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   const mentionIntake = new Map()
   function onEvent(k, d) {
     if (stopping) return
+    if (['channel:message:updated', 'channel:message:deleted', 'channel:message:reaction'].includes(k)) {
+      const event = conversationEventData(d)
+      if (validBackendId(event.channel_id)) {
+        conversationReader.clearChannel(Number(event.channel_id))
+        const mid = event.message?.id ?? event.message_id
+        if (k === 'channel:message:deleted' && validBackendId(mid)) {
+          memory.remember({ key: `deleted-message:${Number(event.channel_id)}:${Number(mid)}`, kind: 'message-deletion', state: 'deleted' })
+          contextService.forget(`message:${Number(event.channel_id)}:${Number(mid)}`)
+          contextService.forgetThread?.(Number(event.channel_id), Number(mid))
+          cancelThread(Number(event.channel_id), Number(mid), 'Source message deleted')
+          // A reply can itself be the accepted request. Cancel just its work,
+          // without standing down unrelated requests in the parent thread.
+          const fromDeletedSource = (delivery) => Number(delivery?.channelId) === Number(event.channel_id) && Number(delivery?.sourceMessageId) === Number(mid)
+          for (const [key, delivery] of pendingReplyDeliveries) if (fromDeletedSource(delivery)) pendingReplyDeliveries.delete(key)
+          for (const queue of Object.values(queues)) queue.cancel((item) => fromDeletedSource(item.delivery), (item) => {
+            item.control.cancelled = true; item.control.wakeRecovery?.()
+            void item.control.runner?.cancelCurrent?.('source-deleted')
+          })
+          persistReplay()
+        } else if (k === 'channel:message:updated') {
+          try { contextService.observe({ name: 'list_message_thread', args: { channel_id: Number(event.channel_id) }, result: event.message }) } catch { /* live read remains authoritative */ }
+        }
+      }
+      return
+    }
     if (k === 'task:comment') return trackOperation(handleTaskComment(d))
     const conversationEvent = k === 'agent:mention' || k === 'agent:message' || k === 'channel:message'
     if (!conversationEvent) return trackOperation(routeEvent(k, d))
@@ -2029,6 +2102,8 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     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 }
+    if (memory.has(`deleted-message:${Number(cid)}:${Number(messageId)}`, 'deleted') || parent != null && memory.has(`deleted-message:${Number(cid)}:${Number(parent)}`, 'deleted')) return
+    conversationReader.clearChannel(Number(cid))
     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.
@@ -2048,9 +2123,10 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       // 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 preliminary = classifyConversationTarget(message, [...selfAliases], { threadOwned: parent != null && memory.has(threadControlKey(cid, parent), 'active') })
       const irrelevant = preliminary.action === 'ignore' && preliminary.reason !== 'unaddressed-thread-activity'
       let rootContent = ''
+      let contextUnavailable = false
       if (parent != null && !irrelevant && preliminary.action !== 'stand_down') {
         const optional = preliminary.explicitSelf || memory.has(threadControlKey(cid, parent), 'active')
         let contextTimer
@@ -2061,20 +2137,25 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
           // before a model starts. Delivery still re-reads the authoritative thread.
           rootContent = optional ? await Promise.race([context, new Promise((resolve) => {
             contextTimer = setTimeout(() => {
+              contextUnavailable = true
               log(`mention optional context pending channel=${cid} message=${messageId} — continuing with verified recipient`)
               resolve('')
             }, 1000)
           })]) : await context
         }
         catch (error) {
+          contextUnavailable = true
           if (!preliminary.explicitSelf && !memory.has(threadControlKey(cid, parent), 'active')) throw error
           log('optional root context unavailable; preserving verified recipient: ' + (error?.message || error))
         }
         finally { clearTimeout(contextTimer) }
       }
+      // Deletion may arrive during identity/history I/O, before there is a
+      // queue entry for cancellation to find. Recheck at the admission boundary.
+      if (memory.has(`deleted-message:${Number(cid)}:${Number(messageId)}`, 'deleted') || parent != null && memory.has(`deleted-message:${Number(cid)}:${Number(parent)}`, 'deleted')) return { status: 'ignored-deleted' }
       if (!stopping) {
         if (!irrelevant) log(`mention timing intake=${Math.round(performance.now() - intakeStartedAt)}ms source=${k} channel=${cid} message=${messageId}`)
-        return routeEvent('agent:mention', { ...eventData, _sourceEvent: k, _threadRootContent: rootContent })
+        return routeEvent('agent:mention', { ...eventData, _sourceEvent: k, _threadRootContent: rootContent, _contextUnavailable: contextUnavailable })
       }
     }).catch((error) => { log('mention thread verification failed: ' + (error?.message || error)); return { status: 'retry' } })
       .finally(() => { if (mentionIntake.get(key) === next) mentionIntake.delete(key) })
@@ -2114,11 +2195,6 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         log('agent:mention replay recovered for active owned thread')
       }
       const loopKey = cid != null && threadRoot != null ? peerTurnKey('channel', cid, threadRoot) : ''
-      if (peerMessage && loopKey && memory.has(loopKey, 'replied')) {
-        log('agent:mention ignored before model start (peer-loop-budget)')
-        return { status: 'ignored-peer-loop' }
-      }
-      if (!peerMessage && loopKey) memory.remember({ key: loopKey, kind: 'peer-turn', state: 'human', summary: text, refs: { channelId: Number(cid), threadId: Number(threadRoot) } })
       const target = classifyConversationTarget(msg, [...selfAliases], { threadOwned })
       if (target.action === 'ignore') {
         log('agent:mention ignored before model start (' + target.reason + ')')
@@ -2139,6 +2215,11 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         }
         return
       }
+      if (peerMessage && loopKey) {
+        const meta = admitPeerTurn(memory.get(loopKey), text, target)
+        if (!meta) { log('agent:mention ignored before model start (peer-loop-budget)'); return { status: 'ignored-peer-loop' } }
+        memory.remember({ key: loopKey, kind: 'peer-turn', state: 'reserved', meta })
+      } else if (loopKey) memory.remember({ key: loopKey, kind: 'peer-turn', state: 'human', summary: text, refs: { channelId: Number(cid), threadId: Number(threadRoot) } })
       if (cid != null && threadRoot != null) activateThread(cid, threadRoot, text)
       memory.remember({ key: sourceKey, kind: 'mention', state: 'received', summary: text, refs: { channelId: cid, threadId: threadRoot, messageId: mid } })
       try { contextService.observe({ name: 'list_message_thread', args: { channel_id: cid, message_id: threadRoot }, result: { ...msg, id: mid, content: String(msg.content || msg.body || msg.text || '') } }) }
@@ -2147,10 +2228,11 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       // redirect can cancel its process. The watcher delivers the final answer
       // for every runtime after an authoritative last-moment thread check.
       const conversationDelivery = (stage = 'reply', skipIfAnyAgentReply = stage !== 'result', allowChannelMessaging = false) => cid != null
-        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, sourceMessageId: mid, watcherOwned: true, allowChannelMessaging, peerLoopKey: peerMessage ? loopKey : '' }
+        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, sourceMessageId: mid, sourceMessage: msg, contextUnavailable: raw._contextUnavailable, watcherOwned: true, allowChannelMessaging, peerLoopKey: peerMessage ? loopKey : '' }
         : null
       // Under-the-hood model control from chat (view / switch the model the agent runs).
       const mcmd = cid != null ? parseModelCmd(text) : null
+      if (peerMessage && mcmd && !mcmd.report) { log('Peer agent cannot change local model configuration'); return }
       if (mcmd) {
         refreshModelSettings()
         const thread = threadRoot != null ? `, parent_id ${threadRoot}` : ''

package/src/work-recovery.mjs

@@ -0,0 +1,35 @@
+// Recover read paths, never replay a possibly successful mutation.
+export async function loadProjectTickets({ projectId, read, listTools, matches = async () => true }) {
+  const rows = data => {
+    const value = Array.isArray(data) ? data : data?.tasks ?? data?.tickets ?? data?.data?.tasks ?? data?.data?.tickets;
+    if (!Array.isArray(value)) throw new Error('Ticket listing returned an unrecognized response');
+    return value.filter(row => row && (row.project_id == null || String(row.project_id) === String(projectId)));
+  };
+  let primary, failure;
+  try { primary = rows(await read('list_tasks', { project_id: projectId })); }
+  catch (error) { failure = error; }
+  if (primary?.length && (await Promise.all(primary.map(matches))).some(Boolean)) return primary;
+  let catalog;
+  try { catalog = await listTools(); }
+  catch (error) { throw failure || error; }
+  const alternate = catalog.find(tool => tool.name === 'get_tickets');
+  const schema = alternate?.inputSchema;
+  // Only use a published schema we can satisfy from authoritative context.
+  if (schema && (schema.required || []).every(key => key === 'project_id')) {
+    const args = schema.properties?.project_id ? { project_id: projectId } : {};
+    const alternateRows = rows(await read('get_tickets', args));
+    return [...new Map([...(primary || []), ...alternateRows].map(row => [String(row.id), row])).values()];
+  }
+  if (failure) throw failure;
+  return primary;
+}
+
+// A narrow guard against promise-only final turns, not a tool-count quota.
+// Completed explanations, verified no-ops and genuine blockers can end normally.
+export function needsWorkContinuation(result, { pendingPlan = false } = {}) {
+  if (!result || result.is_error || !['ok', 'success'].includes(result.subtype) || result.workRequest || result.didCode || result.didRepoMutation || result.didResultMessage) return false;
+  const text = String(result.outputText || '').trim();
+  if (!text) return pendingPlan;
+  if (text.length > 700 || /\b(verified|passed|fixed|completed|found|failed|permission|approval|denied|blocked|missing|unavailable)\b/i.test(text)) return false;
+  return /^(?:(?:okay|ok|sure|understood|acknowledged|got it)[,.!—:\s]+)?(?:I['’]ll|I will|I['’]m going to|I am going to|I['’]m on it|I['’]ll take this on)\b/i.test(text);
+}