openvisio-agent 0.21.1 → 0.23.0

package/src/watch.mjs

@@ -6,13 +6,18 @@
 
 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 { closeSync, writeFileSync, mkdirSync, mkdtempSync, rmSync, existsSync, openSync, readFileSync, readdirSync, unlinkSync } from 'node:fs'
+import { homedir, tmpdir } from 'node:os'
+import { fileURLToPath } from 'node:url'
 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, conversationCreatesTicket, conversationNeedsCode, failedTaskRevisionIsCurrent, mentionDedupeKeys, messageParentId, messageSenderIsSelf, missingRuntimeWorkEvidence, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskAgentIdentifier, taskBelongsToAgent, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
+import { buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, conversationAsksPendingTickets, conversationCreatesTicket, conversationNeedsCode, failedTaskRevisionIsCurrent, mentionDedupeKeys, messageParentId, messageSenderIsSelf, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskAgentIdentifier, taskBelongsToAgent, 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 { createContextService } from './context-service.mjs'
+import { contextToolGuide } from './context-tools.mjs'
+import { toolWithoutCredentialInputs } from './codex-mcp-proxy.mjs'
 import { repositoryHasPrPushAuthorization, configurePrPublishing } from './pr-push.mjs'
 import { createMcpHttpClient } from './mcp-http.mjs'
 import { createCycleQueue } from './cycle-queue.mjs'
@@ -75,9 +80,9 @@ const REPLY_DISCIPLINE = [
   '  • IS IT FOR YOU? Act ONLY on messages addressed to YOU — an @mention of your exact name, a direct question to you, or a reply to something YOU said or did. If a DIFFERENT agent or person was @mentioned or asked to do something, STAY OUT: do not answer for them and do not pick up their task. When it is not yours, posting nothing is the correct move.',
   '  • EVENT NAMES ARE NOT OWNERSHIP. A transport may wake you for activity in a thread you once joined. Trust only the watcher\'s verified recipient decision for the current source message; never infer that every thread update is yours.',
   '  • NO DUPLICATES OR PICKUP NOISE. Before you post, scan the recent thread/channel for what YOU already said. If you already replied to this exact request, do NOT repeat the same message. Do not send a generic pickup acknowledgement; activity shows that work is underway. For longer code work, you may send at most one concrete progress update after work has actually begun, but that update NEVER completes the cycle: keep using tools, then send one distinct verified result or real blocker. One final answer per question.',
-  '  • BE SURE BEFORE YOU SPEAK. Do not claim something is possible, done, or broken until you have actually verified it — call the tool, read the code, check the real state. Never assert then contradict yourself. If you are unsure, verify FIRST, then give ONE clear, final answer instead of thinking out loud across several messages.',
+  '  • BE SURE BEFORE YOU SPEAK. Do not claim something is possible, done, or broken until you have actually verified it — call the tool, read the code, check the real state. Be willing to disagree or revise a conclusion when evidence changes. If you are unsure, investigate and distinguish a finding from an assumption.',
   '  • USE RECALL, NEVER INVENT IT. Before answering a context-dependent question, search the visible thread and use any available history, search, docs, or recall tools. Reuse verified context instead of asking the user to repeat it. If no record exists, say plainly "I don\'t have a record of that". Never fabricate past events, conversations, results, links, PR numbers, deploy URLs, or figures.',
-  '  • LOOK UP ASSIGNED WORK. If someone says they assigned you a task, asks which task is yours, or asks for its status, check the live board yourself with list_agents + list_projects + list_tasks and then get_ticket as needed. Match assignments to your authenticated agent identity. Do not ask the teammate for a project slug, ticket slug, or numeric id before trying those MCP tools; ask only if the live lookup fails or returns genuinely ambiguous matches.',
+  '  • LOOK UP ASSIGNED WORK. If someone says they assigned you a task, asks which task is yours, or asks for its status, check the live board yourself with list_projects + list_tasks and then get_ticket as needed. Use list_agents only if assignment data requires a numeric identity lookup. Match assignments to your authenticated agent identity. Do not ask the teammate for a project slug, ticket slug, or numeric id before trying those MCP tools; ask only if the live lookup fails or returns genuinely ambiguous matches.',
   '  • TICKET SLUGS, NEVER DATABASE IDS. In every human-facing channel message, ticket comment, PR description, summary, blocker, and result, reference a ticket by the exact project-scoped slug returned by get_ticket/list_tasks (for example, `OVS-57`). Numeric project_id and ticket_id values are internal MCP arguments only: never write `#57`, `ticket 57`, or expose a database id to teammates. If the backend omits the slug, use the ticket title or say “the ticket”; do not invent a slug.',
   '  • CLOSE CONCERNS. Never leave a concern, direct question, correction, or blocker addressed to you without a clear response. Acknowledge the concern, act if you can, then report the verified result. If blocked, name the blocker and the exact next action or owner in one message.',
   '  • NEW THREADS BELONG IN YOUR DEDICATED CHANNEL. Reply to an existing request in its original thread. For any fresh top-level thread (results, blockers, or an introduction), use only your own dedicated agent channel, resolved from live list_channels by your exact identity/name. Never open a fresh thread in general, a project channel, or another agent’s channel. If no unique dedicated channel exists, keep results on the ticket and report the missing channel in an existing source thread. Never invent a channel or tool.',
@@ -86,9 +91,9 @@ const REPLY_DISCIPLINE = [
 
 // ── CHAT-ONLY agents (no --workdir): chat/ticket tools, no code surface. ──────
 const CHAT_CHARTER = [
-  'YOU ARE a connected agent in an OpenVisio team, running in CHAT-ONLY mode. Use only tools that actually appear in your openvisio-team tool list. Backend MCP provides post_message, react_message, list_agents, list_projects, list_tasks, get_ticket, update_ticket, and list_activity. A ticket-comment tool is optional and must not be assumed. Some relay runtimes also provide poll_inbox or get_marching_orders. Never call a tool that is absent. You have NO local read, grep, glob, list, file, Bash, git, web, or delegation tools in this mode; use the OpenVisio MCP for live team state and do not inspect the local workspace.',
-  'WORK ETHIC — behave like a dependable teammate: never leave a promise dangling. Either ACT now (reply, or file a ticket) or say plainly you can\'t and offer to file a ticket / tag a coding agent who can. Never invent progress. Close the loop every cycle — the human should never have to remind you to circle back.',
-  '',
+  'You are the same connected OpenVisio teammate in every session. Your role, voice, current request, and available capabilities are supplied with the context.',
+  'Discover tools, retrieve relevant context, explore, plan, and choose your next steps. Use native context management. If local execution or edits are needed and openvisio_request_work_session is advertised, use it to continue the same request in your own workspace. A reply session is an internal scheduling choice, not a reason to ask the teammate to reassign your work.',
+  'Stay honest about what you have checked and what remains uncertain. Do the requested work within its authority, and give a useful final response when you choose to end your turn.',
   REPLY_DISCIPLINE,
 ].join('\n')
 
@@ -100,13 +105,13 @@ const CYCLE_FAST = [
   'New chat activity. Do EXACTLY ONE of these:',
   '  • IF a specific mention/message FOR YOU is given above: reply to THAT ONE message exactly once with post_message, then STOP. Do NOT call poll_inbox and do NOT answer anything else this cycle — you already have the message; polling would make you re-answer it and double-post.',
   '  • IF NO specific mention is given above: call poll_inbox and reply only to items truly directed at YOU (a question to you, or a reply to your own message) — SKIP chatter aimed at someone else / another agent, ignore .tasks/.claimable, at most one reply per channel.',
-  'Post ONE message total for the thing you are answering — compose it fully, then send once. Never send a reply and then a "better" version; never repeat a reply you already sent. Be sure of your answer before sending. If asked for work you have no tool for, say so plainly and offer to file a ticket. 1-3 sentences, no summary. Then stop.',
+  'Post ONE message total for the thing you are answering — compose it fully, then send once. Never send a reply and then a "better" version; never repeat a reply you already sent. Be sure of your answer before sending. If asked for work you have no tool for, say so plainly and offer to file a ticket. Use enough detail to answer the request, then end your turn.',
 ].join('\n')
 
 const COORDINATE = [
   'COORDINATION-ONLY cycle. Use the lightweight lane for messaging, triage, ticket comments, assignment, and board movement.',
   'Call get_marching_orders or poll_inbox only when the event context does not already contain enough detail. Use update_ticket to move a ticket to the correct board column when requested or when non-code work is complete.',
-  'Do not inspect repositories, edit files, run tests, or write code in this cycle. If the request actually requires code and this cycle was misclassified, leave it retryable for the coding lane; report only a concrete routing blocker, never a generic acknowledgement. Do not pretend it is complete.',
+  'Explore the context and available tools as needed; this session has no writable coding workspace. If local work is needed, use openvisio_request_work_session when advertised to continue in your coding workspace. Preserve the current request and recipient.',
   'Respond to every direct concern assigned to you, but post only once per item and never duplicate an existing answer.',
 ].join('\n')
 
@@ -122,7 +127,7 @@ const CODE_CHARTER = [
   '',
   'WORK ETHIC — how a reliable teammate behaves (this is the difference between useful and ignored):',
   '  1. CLOSE THE LOOP in THIS cycle. Never say "I\'ll do X" and stop. If you commit to something, do it NOW — the human must never have to remind you to circle back. Sending an intent or progress message is not a stop condition: continue using tools and send the verified result or blocker afterward.',
-  '  2. FINISH, then REPORT. Always update/move the ticket with update_ticket. Reply in a supplied human source thread when one exists. For backlog-assigned work, do not call post_message yourself: the watcher publishes one evidence-verified result in the dedicated agent channel after the PR and ticket handoff are confirmed.',
+  '  2. FINISH, then REPORT. Update the ticket when the actual work calls for a state change. Reply in a supplied human source thread when one exists. For backlog-assigned work, do not call post_message yourself: the watcher publishes your final response in the dedicated agent channel.',
   '  3. Be honest and specific. Never invent progress. If you are genuinely blocked (missing repo, unclear spec, a failing tool), say exactly what you need in one message — that IS closing the loop.',
   '  4. One final reply per request; answer several nudges together. A single concrete progress update is allowed during longer work, but it must be followed by the final result or blocker in the same cycle.',
   '  5. RECOVER DEAD COMMAND SESSIONS. If write_stdin reports “Unknown process id”, that command session has already exited. Never poll the same process id again. Start a fresh exec_command when more work is required, then continue the task and verify the final state.',
@@ -134,24 +139,20 @@ const CODE_CHARTER = [
 ].join('\n')
 
 const CODE_FULL = [
-  'THIS CYCLE: process only the supplied verified ticket or source request. Do not rediscover the entire backlog when a ticket is already supplied. If no source is provided, discover assigned work using tools that actually exist and select one actionable ticket.',
-  'DO NOT post a promise or pre-work acknowledgement. Start the repository work immediately. Follow the source delivery rule; any permitted progress update must describe work already performed and must be followed by a verified result or concrete blocker.',
-  'For real code work (an assigned ticket, or a mention asking for changes), run the full flow end-to-end:',
-  '  1. GET THE CODE: use verified thread/history/recall context first, locate the target repo under your workspace root, and read its AGENTS.md. Reuse an existing clone; clone only if absent. When the repo exists locally, use Read/Grep/Glob and local git for all code discovery and changes; do not use remote codebase tools. Check `git status` before changing anything and preserve unrelated user work. Update from the remote only when it is safe. Do this yourself; never ask the user for a path you can discover.',
-  '  2. BRANCH: create a unique agent/<identity>-<ticket>-<slug> branch with git switch -c, or use git worktree add -b in a separate directory when the checkout is shared or dirty. Resume an existing branch only after verifying that it belongs to this task. Never reset an existing branch. NEVER work on, commit to, or push main/master.',
-  '  3. CHANGE + VERIFY: Read/Edit/Write the files; run the tests or build if the repo has them.',
-  '  4. COMMIT + PUSH YOUR BRANCH: stage only the specific paths or hunks changed for this task; inspect git diff --cached before committing. If unrelated changes are already staged, use an isolated worktree. Commit with a clear message, then publish only your own agent/* branch using the runtime-specific authorized push flow. Never --force, never push to main/master, never merge.',
-  '  5. RAISE A PR: gh pr create --fill --base <default-branch> --head agent/<slug> (a clear title + a body summarizing the change and how you verified it). Never gh pr merge.',
-  '  6. CLOSE THE LOOP: move/update the ticket with update_ticket. Use a ticket-comment tool for a blocker or clarification only when that tool actually appears; otherwise keep the blocker in the ticket update and let the watcher deliver the visible channel result. When a source thread is supplied, follow its explicit delivery rule: either post once or return final text for watcher delivery. For backlog-only tickets, do not call post_message yourself; the watcher sends one verified dedicated-channel completion message and deduplicates it across reconnects.',
-  'Bash is for git / gh / tests / clone ONLY — never to hunt for credentials (they are given to you above).',
+  'Handle the supplied verified ticket or source request. You decide how to investigate, which tools to use, what context to retain or compact, and when the work is ready for a final response.',
+  'There is no required sequence of tools, code edits, ticket updates, or PR creation. Research, audits, explanations, coordination, and already-satisfied requests may finish without repository changes. Choose validation and delivery appropriate to the actual request.',
+  'Use available tool discovery, resources, history, search, skills, and planning tools when useful. Prefer the repository knowledge graph when available. Recover from optional tool failures using alternatives; report only a limitation that actually prevents the requested outcome.',
+  'A usable local clone is your primary code surface. Preserve unrelated work and use an isolated worktree when needed. Remote codebase tools are a fallback only when the repository cannot be obtained locally. For code changes, verify the result and use the authorized branch/PR flow when the request calls for it.',
+  'You own ticket state: use update_ticket when its state should change, including review, completion, or a real blocker. Ending your turn does not mark the ticket done. Your native final response ends this cycle; it can report a result, ask a necessary question, or explain a blocker. Do not describe unperformed work as complete.',
+  'Follow the supplied source delivery rule. For backlog-only tickets, return your final response; the watcher delivers it once to your dedicated channel. Do not call post_message for that same result.',
 ].join('\n')
 
 const CODE_FAST = [
   'New chat activity. Do EXACTLY ONE of these:',
   '  • IF a specific mention/message FOR YOU is given above: reply to THAT ONE message exactly once with post_message, then STOP. Do NOT call poll_inbox and do NOT answer anything else this cycle — polling would re-surface the same message and make you double-post.',
   '  • IF NO specific mention is given above: call poll_inbox and reply only to items directed at YOU (asks you something, or responds to your own message) — SKIP chatter aimed at someone else / another agent; at most one reply per channel.',
-  'This is the reply lane: do not edit code, create branches, or publish repository changes. If the request was misclassified and requires code work, report the routing blocker in its source thread; do not claim completion or try to change the repository from this lane.',
-  'For a non-code question, post ONE answer and stop. For code work, do not post a generic pickup message. You may post one concrete progress update after work starts, but keep working after it; then post one distinct final result with the PR/test evidence or a real blocker. Never repeat the same message. The final update should be 1-3 sentences.',
+  'Explore the request and its context. If local execution or edits are needed, use openvisio_request_work_session when advertised to continue in your own coding workspace. Do not turn an internal scheduling choice into a reassignment request.',
+  'For a non-code question, post ONE answer and stop. For code work, do not post a generic pickup message. You may post one concrete progress update after work starts, but keep working after it; then post one distinct final result with the PR/test evidence or a real blocker. Never repeat the same message. Let the request determine how much detail the final response needs.',
 ].join('\n')
 
 // ── Workspace-ethics cycles (both chat-only + code agents) ───────────────────
@@ -172,7 +173,8 @@ const SWEEP = [
 ].join('\n')
 
 // Bash covers git/gh/clone/tests; the deny list is where the guardrails live.
-const CODE_TOOLS = ['Read', 'Grep', 'Glob', 'Edit', 'Write', 'MultiEdit', 'TodoWrite', 'Bash', 'mcp__openvisio-team__*']
+const CONTEXT_TOOLS = ['Read', 'Grep', 'Glob', 'TodoWrite', 'ToolSearch', 'WebSearch', 'WebFetch', 'Task', 'Agent', 'Skill']
+const CODE_TOOLS = [...CONTEXT_TOOLS, 'Edit', 'Write', 'MultiEdit', 'Bash', 'mcp__openvisio-team__*']
 // Push + PR creation ARE allowed (agents raise PRs), but main/master, force-pushes,
 // merges and destructive/publishing/repo-deleting commands stay blocked.
 const DENY_TOOLS = [
@@ -190,14 +192,9 @@ const DENY_TOOLS = [
 const FAST = 5000
 const SLOW = 60000
 const IDLE_AFTER = 30000
-// Recycle the warm session after ONE cycle. Autonomy cycles are independent (a
-// mention → a reply, a task → its work), so keeping a session across cycles just
-// re-bills the entire prior history on every new cycle — the #1 token sink. Fresh
-// per cycle keeps each cycle's cost to its own work (the static charter/creds ride
-// in the cached system prompt, so a fresh spawn is cheap).
-const MAX_TURNS = 1
+// Keep source-scoped sessions warm; the native agent owns compaction.
 const SESSION_IDLE_MS = 1200000
-// A single cycle must finish within this or it's abandoned — otherwise a hung
+// A silent runtime is stopped after this inactivity interval — otherwise a hung
 // cycle (e.g. an MCP tool stalling on a down bridge) would leave `busy` stuck
 // true forever and silently queue every later mention. Code cycles get a much
 // longer budget: a real clone → branch → test → push → PR flow legitimately takes
@@ -336,20 +333,21 @@ export async function runWatch({ flags }) {
 }
 
 // Claude keeps its native stream; Codex and OpenCode use Mastra ACP.
-export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model, onTool, onEvent, systemPrompt, canCoordinate = false }) {
+export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model, onTool, onEvent, systemPrompt, getContextEnvironment, canCoordinate = false, workspaceAvailable = !!workdir }) {
   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, onEvent, systemPrompt })
+  const mastraRunner = createMastraAcpRunner({ agent, mcpUrl, mcpHeaders, workdir, canCode, canCoordinate, workspaceAvailable, maxCycleMs, log, debug, model, onTool, onEvent, systemPrompt, getContextEnvironment })
   if (mastraRunner) return mastraRunner
   let child = null
+  let privateMcpDir = ''
+  let contextEnvironment = {}
   // The model the CURRENT session was spawned with. runCycle can pass a different
   // model per cycle (cheap for chat, stronger for code) — a change recycles the
   // session so the new model takes effect.
   let sessionModel = resolveClaudeModel(model) || null
-  let turnsThisSession = 0
   let sessionStartedAt = 0
   let resolveTurn = null
   let cycleTimer = null
@@ -363,6 +361,7 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
   let turnDidResultMessage = false
   let turnDidMcpTaskRead = false
   let turnDidMcpTaskUpdate = false
+  let turnWorkRequest = null
   let turnOutputText = ''
   let turnCycleId = null
   let turnRuntimePid = null
@@ -374,10 +373,11 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
   const clearCycleTimer = () => { if (cycleTimer) { clearTimeout(cycleTimer); cycleTimer = null } }
   const settleTurn = (o) => {
     clearCycleTimer()
+    sessionStartedAt = Date.now()
     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' })
+    if (r && finalText) emit('output.final', { text: safeText(finalText, 8000), status: o.is_error ? 'error' : o.subtype || 'error' })
     const mcpCalls = [...turnToolCalls]
     if (r) r({
       ...o,
@@ -390,7 +390,8 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
       didResultMessage: turnDidResultMessage,
       didMcpTaskRead: turnDidMcpTaskRead,
       didMcpTaskUpdate: turnDidMcpTaskUpdate,
-      outputText: turnOutputText.trim(),
+      outputText: finalText,
+      workRequest: turnWorkRequest,
     })
   }
 
@@ -415,18 +416,34 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
     // The charter + creds ride in the system prompt (cacheable → not re-billed each
     // cycle), leaving only the small per-cycle instruction in the user message.
     const fallbackModels = claudeFallbackModels(sessionModel)
-    const base = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--strict-mcp-config', '--mcp-config', mcpConfig, ...(sessionModel ? ['--model', sessionModel, ...(fallbackModels.length ? ['--fallback-model', fallbackModels.join(',')] : [])] : []), ...(systemPrompt ? ['--append-system-prompt', systemPrompt] : [])]
-    const args = canCode ? [...base, '--allowedTools', ...CODE_TOOLS, '--disallowedTools', ...DENY_TOOLS] : [...base, '--allowedTools', 'mcp__openvisio-team__*']
+    let sessionMcpConfig = mcpConfig
+    if (mcpUrl && mcpHeaders?.['x-agent-api-key'] && mcpHeaders?.['x-agent-identifier']) {
+      if (!privateMcpDir) privateMcpDir = mkdtempSync(join(tmpdir(), 'openvisio-claude-mcp-'))
+      sessionMcpConfig = join(privateMcpDir, 'mcp.json')
+      writeJson(sessionMcpConfig, { mcpServers: { 'openvisio-team': {
+        command: process.execPath, args: [fileURLToPath(new URL('./codex-mcp-proxy.mjs', import.meta.url))],
+        env: {
+          OPENVISIO_CODEX_MCP_URL: mcpUrl,
+          OPENVISIO_CODEX_API_KEY: mcpHeaders['x-agent-api-key'],
+          OPENVISIO_CODEX_IDENTIFIER: mcpHeaders['x-agent-identifier'],
+          OPENVISIO_CAN_CODE: String(canCode),
+          OPENVISIO_WORKSPACE_AVAILABLE: String(workspaceAvailable),
+          ...contextEnvironment,
+        },
+      } } }, true)
+    }
+    const base = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--mcp-config', sessionMcpConfig, ...(sessionModel ? ['--model', sessionModel, ...(fallbackModels.length ? ['--fallback-model', fallbackModels.join(',')] : [])] : []), ...(systemPrompt ? ['--append-system-prompt', systemPrompt] : [])]
+    const args = canCode ? [...base, '--allowedTools', ...CODE_TOOLS, '--disallowedTools', ...DENY_TOOLS] : [...base, '--allowedTools', ...CONTEXT_TOOLS, 'mcp__openvisio-team__*', '--disallowedTools', 'Edit', 'Write', 'MultiEdit', 'Bash']
     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 = ''
     c.stdout.on('data', (d) => {
       if (c !== child) return
+      cycleTimer?.refresh()
       localBuf += d
       let i
       while ((i = localBuf.indexOf('\n')) >= 0) {
@@ -448,6 +465,7 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
         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)
+            if (!block.is_error && use?.name?.endsWith('__' + WORK_SESSION_TOOL)) turnWorkRequest = workSessionRequest(block.content) || turnWorkRequest
             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) }] : [] })
@@ -477,13 +495,7 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
         if (o.type === 'result') {
           log('cycle done (' + (o.subtype || 'ok') + (o.is_error ? ' · ERROR' : '') + ')')
           clearCycleTimer()
-          // Autonomy cycles are independent and MAX_TURNS is one. Do not leave a
-          // full Claude runtime resident until the next event; release its CPU,
-          // memory and file watchers as soon as the result has been received.
-          if (MAX_TURNS === 1 && c === child) {
-            child = null
-            void stopModelProcess(c).then(() => settleTurn(o))
-          } else settleTurn(o)
+          settleTurn(o)
           return
         }
       }
@@ -493,10 +505,11 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
     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]'))
+      : ' [CONTEXT session — advertised tools, reading, search, and planning]'))
   }
 
-  function runCycle(prompt, cycleModel, cycleOptions = {}) {
+  async function runCycle(prompt, cycleModel, cycleOptions = {}) {
+    contextEnvironment = await getContextEnvironment?.() || {}
     return new Promise((resolve) => {
       turnCycleId = cycleOptions.cycleId ?? null
       // A per-cycle model override (e.g. chat on a cheaper model than code) — a
@@ -507,14 +520,13 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
         if (resolvedCycleModel !== cycleModel) log('model ' + cycleModel + ' resolved to Claude family alias ' + resolvedCycleModel)
         sessionModel = resolvedCycleModel
       }
-      if (child && (turnsThisSession >= MAX_TURNS || Date.now() - sessionStartedAt > SESSION_IDLE_MS)) {
-        log('recycling session (turns=' + turnsThisSession + ')')
+      if (child && (Date.now() - sessionStartedAt > SESSION_IDLE_MS)) {
+        log('recycling idle session')
         try { child.kill() } catch { /* already gone */ }
         child = null
       }
       ensureSession()
       if (child) childCycleIds.set(child, turnCycleId)
-      turnsThisSession++
       turnToolCalls = new Set()
       turnToolUses = new Map()
       turnMcpErrors = new Set()
@@ -525,6 +537,7 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
       turnDidResultMessage = false
       turnDidMcpTaskRead = false
       turnDidMcpTaskUpdate = false
+      turnWorkRequest = null
       turnOutputText = ''
       resolveTurn = resolve
       // Backstop: abandon a cycle that never returns a result so `busy` is released
@@ -548,7 +561,10 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
     child = null
     return stopModelProcess(active).then(() => settleTurn({ type: 'result', subtype: 'canceled' }))
   }
-  return { runCycle, canCode, cancelCurrent, close: () => { void cancelCurrent() } }
+  return { runCycle, canCode, cancelCurrent, close: async () => {
+    await cancelCurrent()
+    if (privateMcpDir) { rmSync(privateMcpDir, { recursive: true, force: true }); privateMcpDir = '' }
+  } }
 }
 
 // ── the backend WS loop ──────────────────────────────────────────────────────
@@ -595,16 +611,15 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   const canCode = !!workdir
   // The Mastra bridge authenticates per-CALL: every openvisio-team tool needs
   // agent_identifier + agent_api_key as arguments. Hand them over up front.
-  const authRule = agent !== 'claude'
-    ? 'AUTH: the local OpenVisio MCP bridge injects authentication outside the model. Use only this session’s openvisio-team-watcher server for OpenVisio actions; other installed OpenVisio servers do not receive this bridge’s credentials. If a discovered action requires agent_api_key or agent_identifier, it is not the authenticated watcher action: search for the openvisio-team-watcher version. 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: 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; use advertised actions on the authenticated session server only. Bash/git/gh ARE for code work; this rule only forbids searching for keys.`
+  const authRule = 'AUTH: the local OpenVisio MCP bridge injects authentication outside the model. Use openvisio-team-watcher for Codex/OpenCode and openvisio-team for Claude; these are the authenticated servers for this session. Never add, request, print, or search for agent credentials in tool arguments.'
+  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. Use tool and resource discovery when helpful, and call only advertised capabilities. Tools may be namespaced; use advertised actions on the authenticated session server only. 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, onEvent: emit,
+    cfgKey: identifier, mcpConfig, workdir, workspaceAvailable: canCode, log, debug, model, systemPrompt, onEvent: emit,
+    getContextEnvironment: () => contextService.environment(),
   }
   // One watcher and one WS subscription, with a bounded pool of isolated coding
   // runtimes. Replies serialize within a thread while independent threads run
@@ -632,12 +647,12 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   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. For ticket comments, discover an advertised action and follow its input schema; never invent a tool name or call an unadvertised action.'
+  const backendToolRule = 'TOOL DISCOVERY: use the tools and resources actually advertised by your connected runtime. Native tool_search, MCP resources, history, search, planning, skills, and context compaction are available when the runtime supports them. Discover an absent action before deciding it is unavailable; never invent a tool or its schema. The supplied event identifies the request, so further discovery is your choice when it helps the task.' + '\n\n' + contextToolGuide
   const studioGuide = `\n\nAGENT STUDIO: When a teammate asks to inspect agent activity or change model settings, offer [Open Agent Studio](http://127.0.0.1:4317/#agent=${encodeURIComponent(identifier)}&settings=1). The app renders this link as a button. Studio manages agents on the teammate’s own computer; it does not connect to another teammate’s machine. Prefer this UI over asking people to run model-setting CLI commands.`
   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 + studioGuide
   const fastPrompt = (canCode ? CODE_FAST : CYCLE_FAST) + '\n\n' + backendToolRule + studioGuide
   const coordinatePrompt = COORDINATE + '\n\n' + backendToolRule + studioGuide
-  const guardedReplyPrompt = `WATCHER-DELIVERED REPLY: the watcher has already verified that the current source message is addressed to you. Your current OpenVisio agent identifier is "${identifier}"; do not call list_agents merely to rediscover yourself. Do not call post_message, relay inbox tools, or MCP resource APIs. OpenVisio team-state tools are allowed: when the answer depends on live projects, assignments, tickets, or status, use list_projects/list_tasks/get_ticket as needed and never ask the teammate for a slug that those tools can resolve. A failed read-only discovery call is not a completed action and must not be described as an intervention-level blocker; continue with available live data or state the narrow fact you could not verify. Return only one natural, context-specific reply of 1-3 sentences. Do not echo the request, announce a plan, or add a generic acknowledgement. If the supplied context says the work was completed, lead with the verified result; if it is blocked, name only the real blocker and next action.` + '\n\n' + backendToolRule + studioGuide
+  const guardedReplyPrompt = `WATCHER-DELIVERED REPLY: the watcher has already verified that the current source message is addressed to you. Your current OpenVisio agent identifier is "${identifier}"; do not call list_agents merely to rediscover yourself. Return the final reply for watcher delivery instead of calling post_message for the same result. Discover tools and retrieve additional context as needed. OpenVisio team-state tools are allowed: when the answer depends on live projects, assignments, tickets, or status, use list_projects/list_tasks/get_ticket as needed and never ask the teammate for a slug that those tools can resolve. A failed read-only discovery call is not a completed action and must not be described as an intervention-level blocker; continue with available live data or state the narrow fact you could not verify. Return one natural, context-specific final response with enough detail to address the request. Do not echo the request, announce a plan, or add a generic acknowledgement. If the supplied context says the work was completed, lead with the verified result; if it is blocked, name only the real blocker and next action.` + '\n\n' + backendToolRule + studioGuide
   // Live model state — changeable at runtime by the in-chat `/model` command.
   // codeModel drives full/sweep cycles; chatModel (if set) the lighter fast/intro
   // ones, so routine chatter can run cheaper than real code work.
@@ -713,16 +728,25 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     databasePath: join(stateDir, 'watch-' + slug + '-mastra.db'),
     resourceId: identifier,
   })
+  const contextBackend = new URL(backend || mcpUrl || 'http://local.invalid')
+  const contextService = dependencies.contextService || createContextService({
+    directory: stateDir, resourceId: `${contextBackend.origin}${contextBackend.pathname.replace(/\/$/, '')}:${identifier}`,
+    loadTasks: () => loadPendingTickets(),
+    listTools: async () => (await mcpClient.listTools()).map(toolWithoutCredentialInputs),
+    redact: (text) => apiKey ? String(text).split(apiKey).join('[redacted]') : String(text),
+  })
   // Completion delivery is runtime-owned for assigned coding work. Persist both
   // pending and delivered keys so a reconnect can finish a missed notification
   // without re-running the model or posting the same result twice.
   const pendingCompletionReports = new Set(Array.isArray(replayState.pendingCompletionReports) ? replayState.pendingCompletionReports : [])
+  const pendingAgentResults = new Map(Array.isArray(replayState.pendingAgentResults) ? replayState.pendingAgentResults : [])
+  const finishedTaskVersions = new Map(Array.isArray(replayState.finishedTaskVersions) ? replayState.finishedTaskVersions : [])
   const reportedCompletions = new Set(Array.isArray(replayState.reportedCompletions) ? replayState.reportedCompletions : [])
   const reportedTaskComments = new Set(Array.isArray(replayState.reportedTaskComments) ? replayState.reportedTaskComments : [])
-  // Evidence-gate failures are held at the ticket revision that produced them.
+  // Transport/runtime failures are held at the ticket revision that produced them.
   // 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 : [])
+  const failedTaskVersions = new Map(replayState.completionPolicy === 'agent' && Array.isArray(replayState.failedTaskVersions) ? replayState.failedTaskVersions : [])
   // 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.
@@ -749,6 +773,9 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         blockedTasks: [...blockedTasks],
         blockedTaskRepos: [...blockedTaskRepos],
         pendingCompletionReports: [...pendingCompletionReports],
+        pendingAgentResults: [...pendingAgentResults],
+        finishedTaskVersions: [...finishedTaskVersions],
+        completionPolicy: 'agent',
         reportedCompletions: [...reportedCompletions],
         reportedTaskComments: [...reportedTaskComments],
       }, true)
@@ -817,18 +844,18 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   // Context lines from the events themselves (the WS payload already carries the
   // channel + message / task), so the agent acts on THEM directly instead of
   // hoping poll_inbox re-surfaces the same item. Each queue entry retains that
-  // source independently through work, recovery, and delivery.
+  // source independently through work, continuation, and delivery.
   let backlogProbeBusy = false
   let selfAgentId = null
   let selfOrganizationId = null
-  let completionRecipientName = ''
+  let identityContext = memory.get?.(`identity:${identifier}`)?.meta?.context || agentProfileContext({}, identifier)
   const selfAliases = new Set([slug, identifier].map((value) => String(value || '').toLowerCase()).filter(Boolean))
   const rememberSelfAgent = (self) => {
     if (!self || typeof self !== 'object' || String(self.identifier || self.slug || '') !== identifier) return
     if (validBackendId(self.id)) 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
+    identityContext = agentProfileContext(self, identifier)
+    memory.remember({ key: `identity:${identifier}`, kind: 'identity', state: 'configured', summary: self.name || identifier, meta: { context: identityContext } })
     const organizationId = self.organization_id ?? self.organizationId
     if (validBackendId(organizationId)) {
       selfOrganizationId = Number(organizationId)
@@ -843,6 +870,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     emit('tool.started', { ...metadata, status: 'in_progress' })
     return trackOperation(Promise.resolve().then(() => mcpClient.callTool(name, args)).then((result) => {
       emit('tool.finished', { ...metadata, status: 'completed' })
+      try { contextService.observe({ name, args, result }) } catch { /* optional conversation indexing */ }
       return result
     }, (error) => {
       emit('tool.finished', { ...metadata, status: 'failed' })
@@ -1091,6 +1119,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         content: message,
       }))
       const postedId = result.id ?? result.message?.id ?? result.message_id
+      if (postedId != null) contextService.observe({ name: 'post_message', args: { channel_id: channelId, parent_id: parentId, content: message }, result: { id: postedId } })
       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 } })
@@ -1156,21 +1185,34 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     return true
   }
 
-  const announceTaskCompletion = async (taskRef, result = {}) => {
+  const announceTaskCompletion = async (taskRef, result = {}, isCancelled = () => false) => {
     const projectId = Number(taskRef?.projectId)
     const ticketId = Number(taskRef?.ticketId)
     if (!Number.isFinite(projectId) || !Number.isFinite(ticketId)) return false
     const taskKey = `${projectId}:${ticketId}`
+    if (String(result.outputText || '').trim()) {
+      pendingAgentResults.set(taskKey, { outputText: result.outputText, didChannelMessage: !!result.didChannelMessage })
+      pendingCompletionReports.add(taskKey)
+      trimMap(pendingAgentResults); trimSeen(pendingCompletionReports); persistReplay()
+    }
+    result = pendingAgentResults.get(taskKey)
+    if (!result) return false
     const current = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
     const ticket = current.ticket ?? current.task ?? current
-    const completionTypes = await taskTypeSets(projectId)
-    const report = buildTaskCompletionReport(ticket, { projectId, fallbackText: result.outputText, recipientName: completionRecipientName, completedTypeIds: completionTypes.done, reviewTypeIds: completionTypes.review })
+    if (String(ticket.id) !== String(ticketId) || (ticket.project_id != null && String(ticket.project_id) !== String(projectId)) || !taskBelongsToAgent(ticket, { id: selfAgentId, identifier })) {
+      pendingAgentResults.delete(taskKey); pendingCompletionReports.delete(taskKey); persistReplay()
+      return false
+    }
+    if (isCancelled()) return false
+    const report = result.report || buildTaskCompletionReport(ticket, { projectId, fallbackText: result.outputText, agentFinal: true })
+    if (report && !result.report) { result.report = report; persistReplay() }
+    finishedTaskVersions.set(taskKey, taskRevision(ticket)); trimMap(finishedTaskVersions); persistReplay()
     if (!report) return false
     const memoryKey = `ticket:${projectId}:${ticketId}`
     memory.remember({
       key: memoryKey,
       kind: 'ticket',
-      state: 'handoff',
+      state: 'responded',
       summary: report.content,
       refs: { projectId, ticketId },
       meta: { reportKey: report.key, prUrl: report.prUrl },
@@ -1189,7 +1231,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       reportedTaskComments.add(report.key); trimSeen(reportedTaskComments); persistReplay()
     }
     if (reportedCompletions.has(report.key)) {
-      pendingCompletionReports.delete(taskKey)
+      pendingCompletionReports.delete(taskKey); pendingAgentResults.delete(taskKey)
       persistReplay()
       return true
     }
@@ -1198,15 +1240,16 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     // second top-level copy.
     if (result.didChannelMessage) {
       reportedCompletions.add(report.key); trimSeen(reportedCompletions)
-      pendingCompletionReports.delete(taskKey); persistReplay()
+      pendingCompletionReports.delete(taskKey); pendingAgentResults.delete(taskKey); persistReplay()
       log('completion for ticket #' + ticketId + ' was already posted by the work cycle')
       return true
     }
     const channelId = await projectStatusChannel(projectId)
     if (channelId == null || !Number.isFinite(channelId)) return false
+    if (isCancelled()) return false
     await postMessageOnce({ key: `completion:${report.key}`, projectId, channelId, content: report.content, sourceKey: memoryKey })
     reportedCompletions.add(report.key); trimSeen(reportedCompletions)
-    pendingCompletionReports.delete(taskKey); persistReplay()
+    pendingCompletionReports.delete(taskKey); pendingAgentResults.delete(taskKey); persistReplay()
     memory.remember({ key: memoryKey, kind: 'ticket', state: 'reported', summary: report.content, refs: { projectId, ticketId, channelId }, meta: { reportKey: report.key, prUrl: report.prUrl } })
     log('posted verified completion for ticket #' + ticketId + ' in channel ' + channelId)
     return true
@@ -1311,6 +1354,10 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
           for (const task of Array.isArray(tasksData.tasks) ? tasksData.tasks : []) {
             if (!await resolveTaskOwner(task)) continue
             const taskKey = `${project.id}:${task.id}`
+            if (pendingAgentResults.has(taskKey)) {
+              try { await announceTaskCompletion({ projectId: project.id, ticketId: task.id }) }
+              catch (error) { log('agent result delivery pending: ' + (error?.message || error)) }
+            }
             if (taskIsCompleted(task, doneIds) || taskIsAwaitingReview(task, reviewIds)) {
               memory.remember({ key: `ticket:${project.id}:${task.id}`, kind: 'ticket', state: 'handoff', summary: task.title, refs: { projectId: project.id, ticketId: task.id } })
               if (pendingCompletionReports.has(taskKey)) {
@@ -1418,9 +1465,9 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   const baseFor = (kind, delivery) => delivery?.watcherOwned
     ? (kind === 'full' ? fullPrompt + '\n\n' + guardedReplyPrompt : guardedReplyPrompt)
     : kind === 'intro' ? INTRO : kind === 'full' ? fullPrompt : (kind === 'coord' || kind === 'sweep') ? coordinatePrompt : fastPrompt
-  // Every coding runtime now exposes structured action evidence. A normal CLI
-  // result or assistant prose never closes a work cycle by itself.
-  const cycleSucceeded = (result) => !!result && !result.is_error && [undefined, null, '', 'ok', 'success'].includes(result.subtype)
+  // A native final turn ends a cycle. Ticket completion is a separate board
+  // action chosen by the agent; tool counts never determine either decision.
+  const cycleSucceeded = (result) => !!result && !result.is_error && ['ok', 'success'].includes(result.subtype)
   const releaseTaskForRetry = (taskRef, prompt) => {
     const directProject = Number(taskRef?.projectId)
     const directTicket = Number(taskRef?.ticketId)
@@ -1445,7 +1492,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     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)) })
+      emit(status === 'canceled' ? 'cycle.cancelled' : 'cycle.finished', { ...cycleData, status, finishedBy: control.finishedBy || 'runtime', durationMs: Math.round(performance.now() - (control.startedAt ?? control.enqueuedAt)) })
       return result
     })
   }
@@ -1461,6 +1508,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     log(`cycle timing queue=${Math.round(cycleStartedAt - (cycleControl.enqueuedAt ?? cycleStartedAt))}ms kind=${kind}`)
     const ctx = context ? [context] : []
     const activeTaskRef = taskRef
+    let verifiedTaskRevision = ''
     const ticketWorktree = preparedWorkdir || (kind === 'full' && activeTaskRef ? findTicketWorktree(workdir, activeTaskRef.ticketId) : '')
     const runnerOptions = {
       cycleId: cycleControl.cycleId, attempt: 1,
@@ -1478,8 +1526,13 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const memoryRefs = delivery
       ? { channelId: delivery.channelId, threadId: delivery.parentId }
       : activeTaskRef ? { projectId: activeTaskRef.projectId, ticketId: activeTaskRef.ticketId } : {}
-    const recalled = await memory.context(memoryRefs)
-    const prompt = (ctx.length ? ctx.join('\n') + '\n\n' : '') + (recalled ? recalled + '\n\n' : '') + baseFor(kind, delivery)
+    let recalled = ''
+    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
+      ? 'YOUR CODING WORKSPACE IS AVAILABLE. If this request needs local execution or edits, call openvisio_request_work_session with the findings and context to carry forward, then end this turn. The same agent continues the same request in its coding workspace. Do not claim to be a chat-only agent or ask anyone to reassign the ticket.'
+      : canCode ? 'This session has your configured coding workspace. Choose the tools and context appropriate to the request.' : 'This connection has no configured local coding workspace. Use your available tools for the request; do not claim local changes you cannot perform.'
+    const prompt = identityContext + '\n\n' + capabilityContext + '\n\n' + (ctx.length ? ctx.join('\n') + '\n\n' : '') + (recalled ? recalled + '\n\n' : '') + baseFor(kind, delivery)
     // Chat-shaped cycles (mentions/intro) may run on the cheaper chat model; code
     // work (full/sweep) uses the main model.
     refreshModelSettings()
@@ -1494,6 +1547,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       if (activeTaskRef) {
         const data = toolData(await callMcpTool('get_ticket', { project_id: activeTaskRef.projectId, ticket_id: activeTaskRef.ticketId }))
         const ticket = data.ticket ?? data.task ?? data
+        verifiedTaskRevision = taskRevision(ticket)
         const typeSets = await taskTypeSets(activeTaskRef.projectId)
         if (blockedTasks.has(`${activeTaskRef.projectId}:${activeTaskRef.ticketId}`) ||
             !taskBelongsToAgent(ticket, { id: selfAgentId, identifier }) ||
@@ -1507,7 +1561,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       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'
+      cycleControl.outcome = result?.is_error ? 'error' : result?.subtype || 'error'
       if (result?.timings) log(`cycle timing runtime=${JSON.stringify(result.timings)} kind=${kind}`)
       refreshModelSettings()
       if (cycleModelRevision === modelSettingsRevision && result?.model && result.model !== useModel) {
@@ -1518,7 +1572,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         if (liteModel === useModel) { liteModel = result.model; changed = true }
         if (changed) persistModel()
       }
-      let completionResult = result
+      const completionResult = result
       if (cycleControl.cancelled || result?.subtype === 'canceled') {
         log(laneName + ' cycle cancelled; no blocker or reply will be published')
         return
@@ -1539,56 +1593,36 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         finally { if (activeTaskRef) await finalizeFailedTaskPause(activeTaskRef) }
         return
       }
-      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 }) }
-        catch (e) { log('failed to publish coordination blocker: ' + (e?.message || e)) }
+      if (result?.workRequest && kind !== 'full' && canCode) {
+        // An agent-selected continuation, not a heuristic retry or a new task.
+        // Preserve the authoritative recipient and cancellation key; the tool
+        // cannot select another task, channel, identity, or permission scope.
+        cycleControl.outcome = 'continued'
+        cycleControl.finishedBy = 'agent'
+        const continuation = String(result.workRequest.context || '').slice(0, 12000)
+        const handoffKey = `continuation:${cycleControl.cycleId}`
+        memory.remember({ key: handoffKey, kind: 'continuation', state: 'requested', summary: continuation, refs: memoryRefs, meta: { context: continuation, requestedBy: 'agent' } })
+        const sourceKey = delivery?.sourceKey || (activeTaskRef ? `ticket:${activeTaskRef.projectId}:${activeTaskRef.ticketId}` : '')
+        if (sourceKey) memory.connect(sourceKey, handoffKey, 'continued_with')
+        emit('cycle.continued', { cycleId: cycleControl.cycleId, status: 'continued', reason: 'agent requested coding workspace' })
+        void drain('full', `${context || ''}\n\nYOUR CONTINUATION CONTEXT:\n${continuation}\nContinue the original request using your configured workspace. Preserve the same role, voice, recipient, and authorization.`, targetChannels, activeTaskRef, delivery)
         return
       }
-      if (kind !== 'full' && result?.mcpErrors?.length) {
-        log('reply cycle had read-only MCP failures (' + result.mcpErrors.join(', ') + '); preserving the scoped model reply')
+      // The native runtime's successful final turn is the agent's decision to
+      // yield. Tool activity is telemetry, not a universal completion checklist.
+      // Optional failures and alternative workflows remain the agent's concern.
+      cycleControl.outcome = 'ok'
+      cycleControl.finishedBy = 'agent'
+      if (result?.mcpErrors?.length) log('agent ended its turn with tool diagnostics: ' + result.mcpErrors.join(', '))
+      if (activeTaskRef && !String(completionResult?.outputText || '').trim()) {
+        finishedTaskVersions.set(`${activeTaskRef.projectId}:${activeTaskRef.ticketId}`, verifiedTaskRevision)
+        trimMap(finishedTaskVersions); persistReplay()
       }
-      // Model prose never proves success or a blocker. Full cycles must produce
-      // runtime-observed ticket reads, repository evidence, and ticket updates.
-      const ticketCycle = !!activeTaskRef || /ticket\s+#?\d+.*?project\s+\d+/i.test(prompt)
-      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, 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)) }
-          } else {
-            const unresolved = recoveryMissing.length ? recoveryMissing : [`the recovery cycle ended with ${recovery?.subtype || 'an unknown error'}`]
-            const notice = `I'm blocked after one recovery attempt. Missing required evidence: ${unresolved.join('; ')}. I've paused this revision until the ticket changes, and I'm not claiming completion.`
-            if (activeTaskRef) pauseFailedTask(activeTaskRef)
-            try { await publishBlocker({ prompt, taskRef: activeTaskRef, delivery, notice }) }
-            catch (e) { log('failed to publish recovery blocker: ' + (e?.message || e)) }
-            finally { if (activeTaskRef) await finalizeFailedTaskPause(activeTaskRef) }
-          }
-          log('WORK_CYCLE_FAILED evidence gate still incomplete after one recovery; ticket paused until its revision changes')
-          return
-        }
-        completionResult = recoveredResult
-      }
-      if (kind === 'full' && activeTaskRef) {
+      if (activeTaskRef) {
         try {
-          const delivered = await announceTaskCompletion(activeTaskRef, completionResult)
+          const delivered = await announceTaskCompletion(activeTaskRef, completionResult, () => cycleControl.cancelled)
           if (!delivered) {
-            log('completion report deferred for ticket #' + activeTaskRef.ticketId + '; waiting for verified review/done state and PR evidence without rerunning repository work')
+            log('completion report deferred for ticket #' + activeTaskRef.ticketId + '; waiting for result delivery without rerunning the agent')
           }
         } catch (e) {
           log('completion report failed for ticket #' + activeTaskRef.ticketId + ': ' + (e?.message || e) + '; retained for delivery retry without rerunning repository work')
@@ -1664,6 +1698,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       const belongsToSelf = await resolveTaskOwner(ticket)
       const key = `${projectId}:${ticketId}`
       if (!belongsToSelf) {
+        finishedTaskVersions.delete(key); pendingAgentResults.delete(key)
         for (const [name, queue] of Object.entries(queues)) {
           queue.cancel((item) => String(item.taskRef?.projectId) === String(projectId) && String(item.taskRef?.ticketId) === String(ticketId), (item) => {
             item.control.cancelled = true
@@ -1673,6 +1708,13 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         memory.remember({ key: `ticket:${projectId}:${ticketId}`, kind: 'ticket', state: 'unassigned', summary: ticket.title, refs: { projectId, ticketId } })
         blockedTasks.delete(key); blockedTaskRepos.delete(key); pendingCompletionReports.delete(key); failedTaskVersions.delete(key); persistReplay(); seenTasks.delete(key); log(kind + ' ticket #' + ticketId + ' is not assigned to this agent — ignored'); return
       }
+      if (finishedTaskVersions.has(key)) {
+        if (finishedTaskVersions.get(key) === taskRevision(ticket)) {
+          if (pendingAgentResults.has(key)) await announceTaskCompletion({ projectId, ticketId })
+          return
+        }
+        finishedTaskVersions.delete(key); seenTasks.delete(key); persistReplay()
+      }
       if (taskIsCompleted(ticket, typeSets.done) || taskIsAwaitingReview(ticket, typeSets.review)) {
         memory.remember({ key: `ticket:${projectId}:${ticketId}`, kind: 'ticket', state: 'handoff', summary: ticket.title, refs: { projectId, ticketId } })
         if (pendingCompletionReports.has(key)) {
@@ -1704,10 +1746,9 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       log(kind + ' verified ticket #' + ticketId + ' “' + title + '” -> ' + cycleKind + ' lane')
       const activityChannel = await projectStatusChannel(projectId)
       if (activityChannel != null) sendStatus(activityChannel, 'thinking')
-      if (cycleKind === 'full') { pendingCompletionReports.add(key); trimSeen(pendingCompletionReports); persistReplay() }
       const humanTicketRef = ticketSlug ? `ticket ${ticketSlug}` : `the ticket “${title}”`
       const workspaceDirective = preparedWorktree ? ` A prepared local git worktree for this ticket exists at ${JSON.stringify(preparedWorktree)}. Start repository inspection and edits there. Do not call list_codebases, codebase_tree, or get_codebase while this local worktree is available.` : ''
-      void drain(cycleKind, `Authoritative get_ticket verification confirms ${humanTicketRef} is open and assigned to YOU. Internal tool identity: project_id ${projectId}, ticket_id ${ticketId}. For every get_ticket call pass exactly { project_id: ${projectId}, ticket_id: ${ticketId} }; for list_task_types pass exactly { project_id: ${projectId} }. Numeric ids are MCP arguments only and must never appear in human-facing text; use ${ticketSlug || 'the ticket title'} instead. Ticket details: ${JSON.stringify({ slug: ticketSlug, title, description: ticket.description, priority: ticket.priority, typeId: ticket.type_id ?? ticket.typeId })}.${workspaceDirective} This assignment has no source thread: do not call post_message yourself. Use list_task_types and update_ticket to move it active, complete and verify the work, open the PR when applicable, then update/move the ticket with evidence. For coding work, the watcher will publish exactly one verified completion result in the dedicated agent channel.`, activityChannel == null ? [] : [activityChannel], { projectId, ticketId, channelId: activityChannel })
+      void drain(cycleKind, `Authoritative get_ticket verification confirms ${humanTicketRef} is open and assigned to YOU. Internal tool identity: project_id ${projectId}, ticket_id ${ticketId}. For every get_ticket call pass exactly { project_id: ${projectId}, ticket_id: ${ticketId} }; for list_task_types pass exactly { project_id: ${projectId} }. Numeric ids are MCP arguments only and must never appear in human-facing text; use ${ticketSlug || 'the ticket title'} instead. Ticket details: ${JSON.stringify({ slug: ticketSlug, title, description: ticket.description, priority: ticket.priority, typeId: ticket.type_id ?? ticket.typeId })}.${workspaceDirective} This assignment has no source thread: do not call post_message yourself. Choose the tools, context, validation, and ticket state appropriate to this request. Return your final response when you decide this turn is finished; the watcher will publish it once in the dedicated agent channel without changing ticket status.`, activityChannel == null ? [] : [activityChannel], { projectId, ticketId, channelId: activityChannel })
     } catch (e) {
       log(kind + ' ticket verification failed for #' + ticketId + ': ' + (e?.message || e))
     }
@@ -1826,6 +1867,8 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       }
       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 || '') } }) }
+      catch { /* optional conversation indexing */ }
       // Every runtime carries the source thread through the queue so a later
       // redirect can cancel its process. Codex additionally delegates the final
       // post to the watcher for an authoritative last-moment thread check.
@@ -1891,8 +1934,8 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       const replyDelivery = conversationDelivery(codingMention ? 'result' : 'reply', !codingMention)
       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.'}`
+          ? `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}".` : ''} Use additional discovery, resources, and history when they help answer this request.`
+          : `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)` : ''}, using the authenticated session bridge. 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.` : ''} Use additional discovery, resources, and history when they help answer this request.${codingMention ? ' Stop only after the work and final result/blocker.' : ' After your single reply, STOP.'}`
         : undefined
       if (ctx && creatingTicket) ctx += ' This is a ticket-creation request, not repository implementation. Discover create_ticket on the authenticated watcher server, resolve the project and valid type using list_projects and list_task_types, then create the requested ticket once. Follow its actual schema. If a required detail is ambiguous, ask for that detail rather than inventing it. Report the returned ticket reference. Never replay a creation after a timeout or uncertain response.'
       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.`
@@ -2002,6 +2045,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       await Promise.allSettled([...mentionIntake.values(), ...Object.values(queues).map((queue) => queue.settled()), ...messageDeliveries.values(), ...pendingOperations])
       workRunners.close()
       replyRunners.close()
+      try { await contextService.close() } catch (error) { log('context search shutdown failed: ' + (error?.message || error)) }
       try { await memory.settled?.() }
       catch (error) { log('memory shutdown failed: ' + (error?.message || error)) }
       finally {