openvisio-agent 0.23.0 → 0.24.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.24.0] — 2026-09-10
+
+- Acknowledge accepted coding tasks with the agent's short native plan, then deliver its final response separately. Deduplicate plans through reconnects and use guarded source-thread delivery for every BYO runtime.
+- Enable native coding delegation through Codex multi-agent, OpenCode task, and Claude Agent/Task, with scoped child objectives and parent review.
+- Restore working, thinking, and typing presence through the documented REST endpoint, with per-cycle ownership, throttled refresh, and failure backoff.
+- Remove Studio input outlines and retain a subtle keyboard-focus underline.
+- Keep accepted coding work alive across event WebSocket disconnects. Resume confirmed runtime transport interruptions in the same queue with the original workspace, thread, and partial context; verify ownership again before restarting the model.
+- Wait through known event-channel outages without exhausting retries. Use bounded backoff for provider-only transport failures; preserve agent final responses, cancellation, policy blocks, and guarded delivery.
+- Refresh active cycle state in the Studio journal so long tasks remain visible after their start event leaves the bounded activity window.
+
 ## [0.23.0] — 2026-09-10
 
 - Add local semantic and keyword search over recorded conversations with source references, bounded retention, edit replacement, and backend/agent isolation.

package/README.md

@@ -85,7 +85,7 @@ The backend MCP may be stateful or stateless. A successful initialize response w
 
 Codex BYO agents follow the repository's normative runtime specification in `docs/CODEX_BYO_AGENT_SPEC.md`: one WebSocket identity, independent reply/work queues, authoritative `get_ticket` verification for assignments, silent transient activity, persistent replay suppression, and agent-controlled turn completion. Maintainers must run `npm run certify` before publishing.
 
-Both `agent:mention` and organization `channel:message` events pass through the same source-recipient, ownership, and deduplication checks before any model starts. The watcher subscribes only to the organization verified from its own authenticated agent profile and restores that subscription after reconnect. Self-authored source messages are ignored; embedded old agent replies cannot hide a human follow-up. An explicit tag establishes durable ownership of that thread, so later human follow-ups remain addressed to the agent without another @mention. Messages redirected to another agent and unaddressed agent chatter stay silent, while a direct stand-down cancels queued/running work and releases ownership for that thread. Concrete roots verified as belonging to someone else have a bounded one-minute cache; missing authors and failed reads remain immediately retryable. The watcher does not broadcast working, thinking, or typing presence updates. Claude and OpenCode may add one concrete progress update after work begins, but must continue and post a distinct verified result or blocker afterward; Codex keeps cancellation-safe delivery watcher-owned and renders the verified final answer once.
+Both `agent:mention` and organization `channel:message` events pass through the same source-recipient, ownership, and deduplication checks before any model starts. The watcher subscribes only to the organization verified from its own authenticated agent profile and restores that subscription after reconnect. Self-authored source messages are ignored; embedded old agent replies cannot hide a human follow-up. An explicit tag establishes durable ownership of that thread, so later human follow-ups remain addressed to the agent without another @mention. Messages redirected to another agent and unaddressed agent chatter stay silent, while a direct stand-down cancels queued/running work and releases ownership for that thread. Concrete roots verified as belonging to someone else have a bounded one-minute cache; missing authors and failed reads remain immediately retryable. The watcher publishes working, thinking, and typing presence from actual runtime activity using the authenticated REST endpoint. It stops refreshing when work finishes or is cancelled; the app clears the indicator through its expiry timer. Accepted coding tasks publish a short native plan first; the watcher sends one acknowledgement with up to three steps in the source thread or dedicated channel. Every runtime returns a distinct final answer for guarded watcher delivery. Plans and reconnects cannot duplicate or suppress that final answer.
 
 Ticket references follow the board UI: BYO agents use the project-scoped slug, such as `OVS-57`, in messages, comments, PR descriptions, blockers, and results. Numeric `project_id` and `ticket_id` values remain internal MCP arguments and are never used as human-facing ticket names. If an older backend omits the slug, the agent uses the ticket title rather than inventing one.
 
@@ -98,7 +98,7 @@ openvisio-agent watch --name ada --workdir ~/repo  # allow REAL work on a git br
 openvisio-agent stop --name ada                  # stop service + every ada watcher
 ```
 
-Agents choose their tools, investigation steps, context management, and when to end a turn. Each turn receives the agent’s configured identity, role, and voice when supplied by its profile; that context is cached across restarts. Reply sessions can request their configured coding workspace through `openvisio_request_work_session`, carrying their findings, source thread, and permissions into the continuation. They do not ask you to reassign work because of an internal scheduling choice. A successful native final turn ends the cycle; it does not mark a ticket done. The agent decides when to update the board. Research, audits, and already-satisfied requests can finish without code changes, ticket mutations, or a PR. Tool failures stay visible as diagnostics without forcing another model turn or replacing the agent's explanation.
+Agents choose their tools, investigation steps, context management, and when to end a turn. Coding agents can delegate independent subtasks through the runtime’s native sub-agent tools: Codex multi-agent is enabled, OpenCode permits task delegation, and Claude permits Agent/Task. The parent supplies scoped context and file ownership, works alongside children, reviews their results, and reports once. Delegation depends on the tools advertised by the installed runtime; it does not grant additional task or publishing authority. Each turn receives the agent’s configured identity, role, and voice when supplied by its profile; that context is cached across restarts. Reply sessions can request their configured coding workspace through `openvisio_request_work_session`, carrying their findings, source thread, and permissions into the continuation. They do not ask you to reassign work because of an internal scheduling choice. A successful native final turn ends the cycle; it does not mark a ticket done. The agent decides when to update the board. Research, audits, and already-satisfied requests can finish without code changes, ticket mutations, or a PR. Tool failures stay visible as diagnostics without forcing another model turn or replacing the agent's explanation.
 
 The context graph records source-to-continuation relationships and recalls direct neighbors without walking into unrelated conversations. The watcher saves the agent's final response for delivery retry and avoids rerunning an unchanged assignment after restart. Claude, Codex, and OpenCode keep context within a ticket or conversation; native runtimes handle compaction. A stalled-session watchdog resets when activity arrives, so ongoing work is not stopped by a fixed task duration. Ownership, cancellation, delivery deduplication, credential injection, and repository permissions remain enforced.
 
@@ -116,6 +116,8 @@ Codex and OpenCode use Mastra ACP directly. Work sessions are retained per ticke
 
 Assignments use independent FIFO entries with stable-key duplicate suppression and bounded, worktree-aware concurrency. Backlog recovery uses the same ticket verification path as WebSocket events, and each queued ticket is checked again before a model starts. MCP calls have a 20-second deadline including response bodies; tool discovery is cached and paginated. Codex MCP failures retain a bounded, credential-redacted reason in the watcher log. Cancellation targets only its ACP session. Credentials and replay state use atomic file replacement; Mastra persists contextual memory in libSQL.
 
+An event WebSocket disconnect does not cancel accepted coding work. If the native coding runtime also reports a transport interruption, its queue entry retains the source request, workspace, and partial output. It waits for a known event-channel outage to reconnect, then verifies the ticket again and asks the agent to inspect existing work and uncertain remote writes before continuing. Provider-only interruptions use up to four retries (2, 8, 30, and 60 seconds); repeated failure then reports a blocker. Agent final responses, optional tool errors, explicit cancellation, inactivity timeouts, quota errors, and policy denials do not trigger this recovery. Coordination requests are not automatically replayed. Keep the watcher running during an outage; this recovery retains in-flight context in that watcher, not across process termination.
+
 See `docs/BYO_PERFORMANCE_AUDIT_2026-09-08.md` in the repository for the audit results and remaining live-validation limits. Local certification does not certify a deployed agent's behavior.
 
 `--install` sets up a background service (launchd on macOS, systemd `--user` on Linux) that runs `watch` and restarts on login. Logs go to `~/.openvisio/<agent>.log` (macOS) or `journalctl --user -u openvisio-<agent>` (Linux).

package/USER_GUIDE.md

@@ -76,6 +76,8 @@ Stopping a watcher interrupts its active work. When you are ready to resume, run
 
 Replies stay in their source thread. New completion messages use the agent’s dedicated channel. Check the ticket and any linked pull request for delivered results. A progress message describes ongoing work; wait for the final result or blocker.
 
+For accepted coding tasks, the agent starts by publishing a short plan. You receive one acknowledgement with up to three steps, followed later by its result. The agent can delegate independent pieces to native sub-agents and remains responsible for checking their work. Thinking, working, and typing indicators follow runtime activity; they expire after work stops. A reconnect does not repeat the plan or cancel healthy work.
+
 ## Open Agent Studio
 
 In the app, choose **Agents → Open Agent Studio**. Updated backend watchers start Studio automatically. Agent chat replies can also show this button and open the relevant agent’s settings directly.

package/package.json

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

package/scenarios/runtime.scenarios.mjs

@@ -321,7 +321,7 @@ for (const agent of ['codex', 'opencode']) for (const mode of modes) for (const
       }
       if (agent === 'opencode') {
         const value = JSON.parse(config.env.OPENCODE_CONFIG_CONTENT)
-        if (mode.canCode) assert.equal(value.permission, undefined)
+        if (mode.canCode) assert.deepEqual(value.permission, { task: 'allow' })
         else {
           assert.equal(value.permission.bash, 'deny')
           assert.equal(value.permission['openvisio-team-watcher_*'], 'allow')

package/scenarios/workspace.scenarios.mjs

@@ -16,11 +16,11 @@ async function eventually(predicate, description) {
   assert.fail(`Watcher did not reach: ${description}`)
 }
 
-export function fixture({ agent = 'codex', task = true, run, threadError = false, commentTools = [], onComment, selfProfile = self, listAgents, getTicket, listChannels } = {}) {
+export function fixture({ agent = 'codex', task = true, run, threadError = false, commentTools = [], onComment, selfProfile = self, listAgents, getTicket, listChannels, transportRecoveryDelays, activityReporter } = {}) {
   const dir = mkdtempSync(join(tmpdir(), 'byo-workspace-'))
   const posts = [], runs = [], calls = [], logs = [], messages = [], subscriptions = []
   const ticket = { id: 77, project_id: 1, slug: 'OPEN-77', title: 'Repair the component', agent_id: 7, status: 'In Progress', type_id: 1, updated_at: 'revision-1' }
-  let watcher, messageId = 100, closed = 0
+  let watcher, connection, messageId = 100, closed = 0
   const memory = createByoMemoryGraph({ path: join(dir, 'ledger.json') })
   const mcp = {
     listTools: async () => ['list_agents', 'list_projects', 'list_tasks', 'get_ticket', 'update_ticket', 'post_message', 'list_message_thread', 'list_channels', 'list_task_types', 'list_activity', ...commentTools].map((name) => ({ name })),
@@ -71,7 +71,7 @@ export function fixture({ agent = 'codex', task = true, run, threadError = false
   }
   const start = () => {
     watcher = createBackendWatcher({ wsUrl: 'wss://unused.example.test', mcpUrl: 'https://unused.example.test/mcp', apiKey: 'test-key', identifier: 'alex', slug: 'test-alex', agent, workdir: join(dir, 'workspace'), model: 'test-code', chatModel: 'test-chat' }, {
-      stateDir: dir, memory, mcpClient: mcp, createRunner, connect: () => ({ close() {}, subscribeOrganization(id) { subscriptions.push(id) } }), autoStart: false, log: (value) => logs.push(value),
+      stateDir: dir, memory, mcpClient: mcp, createRunner, transportRecoveryDelays, activityReporter, connect: (callbacks) => { connection = callbacks; return { close() {}, subscribeOrganization(id) { subscriptions.push(id) } } }, autoStart: false, log: (value) => logs.push(value),
     })
     return watcher
   }
@@ -79,6 +79,7 @@ export function fixture({ agent = 'codex', task = true, run, threadError = false
   return {
     dir, ticket, posts, runs, calls, logs, messages, memory, subscriptions,
     get watcher() { return watcher },
+    get connection() { return connection },
     get closed() { return closed },
     set threadError(value) { threadError = value },
     start,

package/scripts/certify.mjs

@@ -91,7 +91,7 @@ const assertions = [
   ['workers serialize shared worktrees while independent worktrees run concurrently', watcher.includes('groupKey: (item) => item.workdir || workdir') && cycleQueue.includes('active.size < concurrency') && cycleQueue.includes('activeGroups.has(candidate[1].group)')],
   ['work and reply cancellation targets are isolated', watcher.includes('item.control.cancelled = true') && watcher.includes('item.control.runner?.cancelCurrent')],
   ['fresh threads resolve the dedicated agent channel', watcher.includes('dedicatedChannel(Array.isArray(channels)') && watcher.includes('No dedicated agent channel available for a new thread')],
-  ['presence notification requests are disabled', watcher.includes('const sendStatus = () => {}') && !watcher.includes('agentStateRequest(') && !watcher.includes("setInterval(() => emitStatusTargets")],
+  ['presence follows runtime activity and stops refreshing with its cycle', watcher.includes('createActivityReporter') && watcher.includes("activity.set(data.cycleId, live.control.statusTargets, 'working')") && watcher.includes('activity.clear(cycleControl.cycleId)')],
   ['websocket client cannot emit legacy agent_status', !websocket.includes('agent_status')],
   ['frontend consumes thinking event', activityHook.includes("'channel:agent:thinking'")],
   ['frontend consumes working event', activityHook.includes("'channel:agent:working'")],

package/src/activity-reporter.mjs

@@ -0,0 +1,47 @@
+import { agentStateRequest } from './events.mjs'
+
+// Presence is ephemeral, independent of task completion and message delivery.
+// The backend supports no "done" event; stopping refresh lets the UI TTL clear it.
+export function createActivityReporter({ backend, apiKey, identifier, fetchImpl = fetch, now = Date.now, log = () => {}, intervalMs = 3_000 }) {
+  const cycles = new Map(), channels = new Map(), pending = new Set()
+  let closed = false
+  const pulse = () => {
+    if (closed || !backend) return
+    const states = new Map()
+    const priority = { thinking: 0, working: 1, typing: 2 }
+    for (const cycle of cycles.values()) for (const channelId of cycle.channels) {
+      if (!states.has(channelId) || priority[cycle.state] > priority[states.get(channelId)]) states.set(channelId, cycle.state)
+    }
+    for (const [channelId, state] of states) {
+      const prior = channels.get(channelId)
+      if (prior?.busy || now() < (prior?.retryAt || 0) || (prior?.state === state && now() - prior.at < (state === 'working' ? 10_000 : 3_000))) continue
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), 5_000)
+      timer.unref?.()
+      const entry = { state, at: now(), busy: true, controller }
+      channels.set(channelId, entry)
+      const request = agentStateRequest(backend, channelId, state, apiKey, identifier)
+      const operation = Promise.resolve().then(() => fetchImpl(request.url, { ...request.init, signal: controller.signal })).then(async response => {
+        await response.body?.cancel?.()
+        if (!response.ok) throw new Error(`HTTP ${response.status}`)
+      }).catch(error => {
+        entry.retryAt = now() + 30_000
+        if (!closed) log('Activity update unavailable; backing off: ' + String(error?.message || 'request failed').slice(0, 100))
+      }).finally(() => { clearTimeout(timer); entry.busy = false; pending.delete(operation) })
+      pending.add(operation)
+    }
+  }
+  const timer = intervalMs > 0 ? setInterval(pulse, intervalMs) : null
+  timer?.unref?.()
+  return {
+    set(cycleId, channelIds, state) {
+      if (closed || !['thinking', 'working', 'typing'].includes(state)) return
+      const valid = [...new Set([...channelIds].map(Number).filter(id => Number.isSafeInteger(id) && id > 0))]
+      cycles.set(cycleId, { channels: valid, state }); pulse()
+    },
+    clear(cycleId) { cycles.delete(cycleId); pulse() },
+    pulse,
+    async settled() { await Promise.allSettled([...pending]) },
+    async close() { closed = true; clearInterval(timer); cycles.clear(); for (const entry of channels.values()) entry.controller.abort(); await Promise.allSettled([...pending]) },
+  }
+}

package/src/mastra-harness.mjs

@@ -8,6 +8,7 @@ import { codexPolicyBlock } from './events.mjs'
 import { WORK_SESSION_TOOL, workSessionRequest } from './runtime-control.mjs'
 import { contextToolNames } from './context-tools.mjs'
 import { buildOpencodeConfig } from './opencode-config.mjs'
+import { isTransportInterruption } from './transport-recovery.mjs'
 
 const MCP_TOOL_NAMES = [
   WORK_SESSION_TOOL, ...contextToolNames, 'list_agents', 'list_projects', 'list_tasks', 'list_task_types', 'get_ticket',
@@ -196,7 +197,7 @@ export function createMastraAcpRunner({
           // codex-acp otherwise keeps a pre-existing openvisio-team server and
           // silently discards this session's authenticated stdio bridge.
           DISABLE_MCP_CONFIG_FILTERING: 'true',
-          CODEX_CONFIG: JSON.stringify({ 'mcp_servers.openvisio-team.enabled': false }),
+          CODEX_CONFIG: JSON.stringify({ 'mcp_servers.openvisio-team.enabled': false, ...(canCode ? { 'features.multi_agent': true } : {}) }),
         } : agent === 'opencode' ? {
           // Reply sessions can explore and manage context without a writable workspace.
           OPENCODE_CONFIG_CONTENT: JSON.stringify({
@@ -398,7 +399,7 @@ export function createMastraAcpRunner({
       log(`${agent} cycle done via Mastra ACP (${subtype}${!canceled && safeError ? ': ' + clean(safeError, 1200) : ''})`)
       invalidate()
       return {
-        type: 'result', subtype, userMessage: providerFailure, runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),
+        type: 'result', subtype, transportInterrupted: subtype === 'error' && isTransportInterruption(error), userMessage: providerFailure, 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,

package/src/opencode-config.mjs

@@ -12,7 +12,6 @@ export function opencodeRuntimeLayout({ cfgKey, workdir, baseDir = OV_DIR }) {
 }
 
 export function buildOpencodeConfig({ mcpUrl, mcpHeaders, canCode = true }) {
-  if (!mcpUrl && canCode) return null
   // Keep local writes scoped to coding connections while allowing the agent
   // to explore tools, retrieve context, plan, and use native compaction.
   const replyPermissions = {
@@ -36,6 +35,7 @@ export function buildOpencodeConfig({ mcpUrl, mcpHeaders, canCode = true }) {
   }
   return {
     $schema: 'https://opencode.ai/config.json',
+    ...(canCode ? { permission: { task: 'allow' } } : {}),
     ...(!canCode ? {
       permission: replyPermissions,
       // Agent-level rules take precedence over global permissions. Select this

package/src/transport-recovery.mjs

@@ -0,0 +1,25 @@
+// Only runtime/transport diagnostics belong here. Agent prose and failed
+// optional tool calls must never turn a successful final response into a retry.
+const transportCodes = new Set(['ECONNRESET', 'ECONNREFUSED', 'ECONNABORTED', 'EPIPE', 'ETIMEDOUT', 'ENETDOWN', 'ENETUNREACH', 'EHOSTUNREACH', 'EAI_AGAIN', 'UND_ERR_SOCKET', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT'])
+
+export function isTransportInterruption(error) {
+  const visited = new Set()
+  const inspect = (value) => {
+    if (!value || visited.has(value)) return false
+    visited.add(value)
+    if (typeof value === 'object') {
+      if (transportCodes.has(String(value.code || '').toUpperCase())) return true
+      return inspect(value.message) || inspect(value.cause) || inspect(value.data) || (Array.isArray(value.errors) && value.errors.some(inspect))
+    }
+    if (typeof value !== 'string') return false
+    return /\b(?:ECONNRESET|ECONNREFUSED|EPIPE|ENETUNREACH|EAI_AGAIN|UND_ERR_SOCKET)\b|socket hang up|stream disconnected before completion|(?:connection|websocket|transport) (?:was |is |unexpectedly )?(?:closed|lost|terminated)|network connection (?:lost|failed)/i.test(value)
+  }
+  return inspect(error)
+}
+
+export function interruptedRuntimeResult(result) {
+  if (!result || ['ok', 'success', 'canceled', 'cancelled', 'blocked', 'rate_limited', 'timeout'].includes(result.subtype) || result.policyBlock) return false
+  return result.transportInterrupted === true || isTransportInterruption(result.error) || isTransportInterruption({ errors: result.errors })
+}
+
+export const transportRecoveryDelays = [2_000, 8_000, 30_000, 60_000]

package/src/watch.mjs

@@ -22,6 +22,8 @@ import { repositoryHasPrPushAuthorization, configurePrPublishing } from './pr-pu
 import { createMcpHttpClient } from './mcp-http.mjs'
 import { createCycleQueue } from './cycle-queue.mjs'
 import { createRunnerPool } from './runner-pool.mjs'
+import { createActivityReporter } from './activity-reporter.mjs'
+import { interruptedRuntimeResult, isTransportInterruption, transportRecoveryDelays } from './transport-recovery.mjs'
 import { mapConcurrent } from './concurrency.mjs'
 import { releaseAuthorizedPause } from './authorization-resume.mjs'
 import { dedicatedChannel, repliesAfterSource } from './channel-routing.mjs'
@@ -79,7 +81,7 @@ const REPLY_DISCIPLINE = [
   '  • FIRST-PERSON VOICE. Speak as yourself: use “I”, “I\'m”, and “my”. Never refer to yourself by your agent name or in the third person, and never restate your own name in introductions, acknowledgements, progress, blockers, or results. The app already shows who sent the message. Sound like a warm, accountable teammate, not a status bot.',
   '  • 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.',
+  '  • ACKNOWLEDGE TASKS, THEN DO THE WORK. Before starting an accepted task, publish a short, concrete plan using the native planning tool. The watcher sends one acknowledgement with your first 2-3 steps to the source thread. Do not post the same acknowledgement yourself. An acknowledgement or plan never completes the task: continue working, then give one distinct verified result or real blocker. Ordinary questions need only their answer; reconnects must not repeat the task acknowledgement.',
   '  • 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_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.',
@@ -140,6 +142,8 @@ const CODE_CHARTER = [
 
 const CODE_FULL = [
   '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.',
+  'Before starting the task, use your native planning tool (update_plan, TodoWrite, or todowrite when advertised) to publish 2-3 short, concrete steps based on the supplied request. The watcher delivers this as your acknowledgement and brief plan. Keep working after the plan; only your final response ends the turn. Do not repeat the acknowledgement after a transport recovery.',
+  'DELEGATION: Use native sub-agents for independent subtasks when they can shorten the work. Discover the runtime tools actually available: Codex spawn_agent/wait/send_input/close_agent, Claude Agent/Task, or OpenCode task. Give each child a bounded objective, relevant context, and explicit file ownership or a separate worktree. Work on another independent part while they run. Children inherit the current task authority; they cannot bypass a policy block, publish unrelated work, or answer the teammate separately. Review and integrate their results, close finished children, and deliver one parent response. Keep delegation bounded (normally at most three children); do not delegate trivial or dependent steps. If the runtime lacks delegation, continue locally and be clear about that limit.',
   '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.',
@@ -152,7 +156,7 @@ const CODE_FAST = [
   '  • 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.',
   '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.',
+  'For a non-code question, post ONE answer and stop. For code work, continue into your coding workspace, publish the short task plan for watcher acknowledgement, and keep working; then give one distinct final result with the evidence or a real blocker. Never repeat the acknowledgement or result.',
 ].join('\n')
 
 // ── Workspace-ethics cycles (both chat-only + code agents) ───────────────────
@@ -167,7 +171,7 @@ const INTRO = [
 const SWEEP = [
   'DAILY CATCH-UP — you may have missed items while offline. Prioritize TASKS.',
   'Use the available task/inbox tools. If get_marching_orders/poll_inbox are absent, use list_agents + list_projects + list_tasks to find tasks assigned to your agent identity, then:',
-  '  1. For every task assigned to YOU that you have NOT started: begin the work without a pickup acknowledgement. Use update_ticket while working and report only a verified result or concrete blocker through an actual source channel when one is supplied. Then do the work end-to-end. Skip tasks assigned to other agents.',
+  '  1. For every task assigned to YOU that you have NOT started: publish a short task plan for watcher acknowledgement, then do the work end-to-end. Use update_ticket when appropriate and report a verified result or concrete blocker. Skip tasks assigned to other agents.',
   '  2. Answer only the @mentions / follow-ups that were directed at YOU and that you have not already answered — at most one reply per channel. Do not reply to threads aimed at someone else.',
   'If there is genuinely nothing outstanding, STOP silently — do NOT post a "nothing to do" message.',
 ].join('\n')
@@ -344,6 +348,7 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
   let child = null
   let privateMcpDir = ''
   let contextEnvironment = {}
+  let disabledMcpTools = []
   // 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.
@@ -428,6 +433,7 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
           OPENVISIO_CODEX_IDENTIFIER: mcpHeaders['x-agent-identifier'],
           OPENVISIO_CAN_CODE: String(canCode),
           OPENVISIO_WORKSPACE_AVAILABLE: String(workspaceAvailable),
+          OPENVISIO_CODEX_DISABLED_TOOLS: JSON.stringify(disabledMcpTools),
           ...contextEnvironment,
         },
       } } }, true)
@@ -510,6 +516,12 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
 
   async function runCycle(prompt, cycleModel, cycleOptions = {}) {
     contextEnvironment = await getContextEnvironment?.() || {}
+    const nextDisabled = [...(cycleOptions.disabledMcpTools || [])].sort()
+    if (JSON.stringify(nextDisabled) !== JSON.stringify(disabledMcpTools) && child) {
+      const previous = child; child = null
+      await stopModelProcess(previous)
+    }
+    disabledMcpTools = nextDisabled
     return new Promise((resolve) => {
       turnCycleId = cycleOptions.cycleId ?? null
       // A per-cycle model override (e.g. chat on a cheaper model than code) — a
@@ -597,6 +609,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   const journal = runtimeJournal({ stateDir, agent: { identifier, slug, provider: agent }, secrets: [apiKey] }, dependencies.journal)
   const emit = (type, data = {}) => journal.emit(type, { watcherPid: process.pid, ...data })
   let cycleSequence = 0
+  const liveCycles = new Map()
   let mcpSequence = 0
   const cycleContext = new AsyncLocalStorage()
   emit('watcher.started', { status: 'running', model, chatModel, workdir: workdir || '' })
@@ -604,10 +617,23 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   // Activity belongs to an individual cycle. Independent ticket workers must
   // not clear or overwrite each other's status targets.
   const replyStatusTargets = new Set()
-  // Working/thinking/typing presence updates are intentionally silent. They
-  // generated notification noise without adding durable progress evidence.
-  const sendStatus = () => {}
+  const activity = dependencies.activityReporter || createActivityReporter({ backend, apiKey, identifier, log })
+  const sendStatus = (channelId, state) => {
+    const id = cycleContext.getStore()?.cycleId
+    const live = liveCycles.get(id)
+    if (live && !live.control.cancelled) activity.set(id, live.control.statusTargets.size ? live.control.statusTargets : [channelId], state)
+  }
   const emitStatusTargets = (targets, state) => { for (const c of targets) sendStatus(c, state) }
+  const runtimeEvent = (type, data = {}) => {
+    emit(type, data)
+    const live = liveCycles.get(data.cycleId)
+    if (!live || live.control.cancelled || stopping) return
+    if (type === 'tool.started' || type === 'tool.updated') activity.set(data.cycleId, live.control.statusTargets, 'working')
+    if (type === 'output.progress') activity.set(data.cycleId, live.control.statusTargets, 'typing')
+    if (type === 'plan.updated' && live.data.kind === 'full' && data.entries?.some(entry => typeof entry?.content === 'string' && entry.content.trim()) && !live.control.planDelivery) {
+      live.control.planDelivery = trackOperation(publishWorkPlan(live, data.entries)).catch(error => log('Task plan delivery unavailable: ' + (error?.message || error)))
+    }
+  }
   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.
@@ -618,7 +644,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   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, workspaceAvailable: canCode, log, debug, model, systemPrompt, onEvent: emit,
+    cfgKey: identifier, mcpConfig, workdir, workspaceAvailable: canCode, log, debug, model, systemPrompt, onEvent: runtimeEvent,
     getContextEnvironment: () => contextService.environment(),
   }
   // One watcher and one WS subscription, with a bounded pool of isolated coding
@@ -626,6 +652,9 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   // concurrently behind the same delivery guards.
   const MAX_CONCURRENT_WORKERS = 3
   const activeWorkRunners = new Set()
+  const recoveryWaiters = new Set()
+  const recoveryDelays = dependencies.transportRecoveryDelays || transportRecoveryDelays
+  let eventConnection = 'unknown'
   const createWorkRunner = (control, workerWorkdir = '') => makeRunner({
     ...runnerOptions,
     ...(workerWorkdir ? { workdir: workerWorkdir } : {}),
@@ -652,7 +681,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   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. 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
+  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 or replace the final answer with a plan. Task acknowledgements are delivered separately from your native plan; ordinary questions need only their answer. 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.
@@ -681,7 +710,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         const runner = workRunners.acquire(sessionKey, { control: item.control, workdir: item.workdir })
         item.control.runner = runner
         activeWorkRunners.add(runner)
-        try { return await cycleContext.run({ cycleId: item.control.cycleId }, () => executeCycle(item.kind, item.context, item.targetChannels, item.taskRef, item.delivery, runner, item.control, item.workdir)) }
+        try { return await cycleContext.run({ cycleId: item.control.cycleId }, () => executeRecoverableCycle(item, runner)) }
         finally { workRunners.release(sessionKey); activeWorkRunners.delete(runner); item.control.runner = null }
       },
       onError: (error, item) => {
@@ -743,7 +772,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   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 : [])
-  // Transport/runtime failures are held at the ticket revision that produced them.
+  // Unrecoverable 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(replayState.completionPolicy === 'agent' && Array.isArray(replayState.failedTaskVersions) ? replayState.failedTaskVersions : [])
@@ -1030,6 +1059,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     for (const [laneName, queue] of Object.entries(queues)) {
       queue.cancel((item) => sameDeliveryThread(item.delivery, channelId, parentId), (item) => {
         item.control.cancelled = true
+        item.control.wakeRecovery?.()
         log(`${laneName} lane cancelled by a newer redirect/stand-down in thread ${parentId}`)
         void item.control.runner?.cancelCurrent?.('thread-cancelled')
       })
@@ -1058,7 +1088,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     identity: () => ({ id: selfAgentId, identifier, slug, name: slug }),
     load: async (cid, root) => toolData(await callMcpTool('list_message_thread', { channel_id: Number(cid), message_id: Number(root) })),
   })
-  const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', sourceMessageId, allowCancelled = false }) => {
+  const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', sourceMessageId, allowCancelled = false, isCancelled = () => false }) => {
     if (stopping) throw new Error('Watcher is stopping')
     const deliveryKey = String(key || '')
     if (parentId == null) {
@@ -1075,6 +1105,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     if (messageDeliveries.has(deliveryKey)) return messageDeliveries.get(deliveryKey)
     const controlKey = threadControlKey(channelId, parentId)
     const suppressCancelled = () => {
+      if (isCancelled()) return { posted: false, reason: 'cycle-cancelled' }
       if (memory.has(deliveryKey, 'suppressed')) return { posted: false, reason: 'source-cancelled' }
       if (allowCancelled || !controlKey || !memory.has(controlKey, 'cancelled')) return null
       pendingReplyDeliveries.delete(deliveryKey)
@@ -1094,7 +1125,8 @@ 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 rendered = repliesAfterSource(renderedAgentMessages(live, { id: selfAgentId, identifier, slug, name: slug }), sourceMessageId)
+        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))
         if (duplicate || (skipIfAnyAgentReply && rendered.length)) {
           deliveredReplies.add(deliveryKey); trimSeen(deliveredReplies); persistReplay()
@@ -1133,6 +1165,26 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     return run
   }
 
+  async function publishWorkPlan(live, entries) {
+    const { control, delivery, taskRef } = live
+    const steps = (Array.isArray(entries) ? entries : []).filter(entry => entry && typeof entry.content === 'string' && entry.content.trim()).slice(0, 3).map(entry => entry.content.trim().slice(0, 240))
+    if (!steps.length || control.cancelled || !control.planKey || memory.has(control.planKey)) return
+    const content = `${control.taskLabel ? `I'm on ${control.taskLabel}.` : "I'll take this on."}\n\n${steps.map((step, index) => `${index + 1}. ${step}`).join('\n')}`
+    const channelId = delivery?.channelId ?? taskRef?.channelId ?? await projectStatusChannel(taskRef?.projectId)
+    if (channelId == null || control.cancelled) return
+    const refs = { channelId: Number(channelId), ...(delivery?.parentId != null ? { threadId: Number(delivery.parentId) } : {}) }
+    // Remember intent before a potentially ambiguous write. A later final reply
+    // must not be mistaken for a duplicate of this plan, even after reconnect.
+    memory.remember({ key: control.planKey, kind: 'work-plan', state: 'attempted', summary: content, refs, meta: { sourceKey: delivery?.sourceKey || '' } })
+    try {
+      await postMessageOnce({ key: control.planKey + ':delivery', channelId, parentId: delivery?.parentId, projectId: taskRef?.projectId, sourceKey: delivery?.sourceKey, sourceMessageId: delivery?.sourceMessageId, content, isCancelled: () => control.cancelled })
+    } finally {
+      // An acknowledgement is only useful before work completes. Never leave a
+      // delayed pickup message queued behind a delivered final response.
+      pendingReplyDeliveries.delete(control.planKey + ':delivery'); persistReplay()
+    }
+  }
+
   let deliveryProbeBusy = false
   const flushPendingReplies = async () => {
     if (stopping || deliveryProbeBusy) return
@@ -1489,21 +1541,57 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const cycleId = `${journal.runId}:cycle:${++cycleSequence}`
     const control = { cycleId, outcome: 'queued', cancelled: false, runner: null, statusTargets: new Set(), enqueuedAt: performance.now() }
     const cycleData = { cycleId, kind, lane: laneName, model: kind === 'full' ? codeModel : liteModel, workdir: itemWorkdir || (laneName === 'work' ? workdir : ''), ...(taskRef ? { ticket: { projectId: taskRef.projectId, ticketId: taskRef.ticketId } } : {}), ...(delivery ? { thread: { channelId: delivery.channelId, threadId: delivery.parentId } } : {}) }
+    liveCycles.set(cycleId, { data: cycleData, control, taskRef, delivery })
     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, finishedBy: control.finishedBy || 'runtime', durationMs: Math.round(performance.now() - (control.startedAt ?? control.enqueuedAt)) })
+      liveCycles.delete(cycleId)
+      activity.clear(cycleId)
       return result
     })
   }
 
+  async function executeRecoverableCycle(item, runner) {
+    const { control } = item
+    let partialOutput = ''
+    for (let attempt = 1; !stopping && !control.cancelled; attempt++) {
+      control.attempt = attempt
+      let interruption
+      const continuation = attempt === 1 ? '' : '\n\nTRANSPORT RECOVERY: The previous runtime was interrupted before an agent final response. Continue the original request in the existing workspace. Inspect current files, git state, and live task/thread history first; edits and remote writes may already have succeeded. Do not blindly repeat commits, ticket creation, comments, or other writes. Verify uncertain outcomes before acting. You decide the remaining work and when to finish.' + (partialOutput ? '\nPrevious partial output (not a final result):\n' + partialOutput : '')
+      try {
+        interruption = await executeCycle(item.kind, item.context + continuation, item.targetChannels, item.taskRef, item.delivery, runner, control, item.workdir)
+        if (!interruption?.transportInterrupted) return
+        partialOutput = String(interruption.outputText || partialOutput).slice(-12000)
+      } catch (error) {
+        if (stopping || control.cancelled) return
+        if (attempt > recoveryDelays.length || !isTransportInterruption(error)) throw error
+      }
+      if (stopping || control.cancelled) return
+      control.outcome = 'recovering'
+      activity.clear(control.cycleId)
+      const delayMs = recoveryDelays[attempt - 1]
+      emit('cycle.recovering', { cycleId: control.cycleId, status: 'recovering', attempt, retryInMs: delayMs, reason: 'Runtime connection interrupted; preserving accepted work' })
+      log(`coding runtime connection interrupted; resuming attempt ${attempt + 1} in ${delayMs / 1000}s or on reconnect`)
+      await new Promise((resolve) => {
+        const wake = () => { clearTimeout(timer); recoveryWaiters.delete(wake); control.wakeRecovery = null; resolve() }
+        // A known event-channel outage can last longer than the retry budget.
+        // Keep accepted work pending until reconnect instead of burning model
+        // attempts while offline. Provider-only failures still use backoff.
+        const timer = setTimeout(() => { if (eventConnection !== 'disconnected') wake() }, delayMs)
+        recoveryWaiters.add(wake)
+        control.wakeRecovery = wake
+      })
+    }
+  }
+
   async function executeCycle(kind, context, targetChannels = [], taskRef = null, delivery = null, runner, control, preparedWorkdir = '') {
     refreshModelSettings()
     const laneName = kind === 'full' ? 'work' : 'reply'
     const cycleControl = control || { cancelled: false, runner, statusTargets: new Set() }
     const cycleStartedAt = performance.now()
-    cycleControl.startedAt = cycleStartedAt
-    cycleControl.outcome = 'skipped'
+    cycleControl.startedAt ??= cycleStartedAt
+    cycleControl.outcome = 'preflight'
     emit('cycle.started', { cycleId: cycleControl.cycleId, kind, lane: laneName, status: 'preflight', model: kind === 'full' ? codeModel : liteModel, workdir: preparedWorkdir || (kind === 'full' ? workdir : ''), ...(taskRef ? { ticket: { projectId: taskRef.projectId, ticketId: taskRef.ticketId } } : {}), ...(delivery ? { thread: { channelId: delivery.channelId, threadId: delivery.parentId } } : {}), queueMs: Math.round(cycleStartedAt - (cycleControl.enqueuedAt ?? cycleStartedAt)) })
     log(`cycle timing queue=${Math.round(cycleStartedAt - (cycleControl.enqueuedAt ?? cycleStartedAt))}ms kind=${kind}`)
     const ctx = context ? [context] : []
@@ -1511,12 +1599,12 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     let verifiedTaskRevision = ''
     const ticketWorktree = preparedWorkdir || (kind === 'full' && activeTaskRef ? findTicketWorktree(workdir, activeTaskRef.ticketId) : '')
     const runnerOptions = {
-      cycleId: cycleControl.cycleId, attempt: 1,
+      cycleId: cycleControl.cycleId, attempt: cycleControl.attempt || 1,
       ...(delivery?.watcherOwned ? { disabledMcpTools: ['post_message'] } : {}),
       ...(ticketWorktree ? { workdir: ticketWorktree } : {}),
     }
     const targets = [...new Set(targetChannels.filter((id) => id != null && Number.isFinite(Number(id))).map(Number))]
-    cycleControl.statusTargets = laneName === 'reply' ? replyStatusTargets : new Set(targets)
+    cycleControl.statusTargets = new Set(targets)
     if (laneName === 'reply') {
       replyStatusTargets.clear()
       for (const target of targets) replyStatusTargets.add(target)
@@ -1539,8 +1627,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const cycleModelRevision = modelSettingsRevision
     const useModel = kind === 'full' ? codeModel : liteModel
     log('running ' + kind + ' cycle…' + (ctx.length ? ' (' + ctx.length + ' event' + (ctx.length === 1 ? '' : 's') + ')' : '') + (useModel ? ' [' + useModel + ']' : ''))
-    // Presence notifications are intentionally disabled; durable messages and
-    // ticket transitions are the only user-visible progress signals.
+    activity.set(cycleControl.cycleId, cycleControl.statusTargets, 'thinking')
     try {
       // The ticket may have been reassigned or handed to review while waiting.
       // Re-check at dequeue, before any model can edit the repository.
@@ -1548,19 +1635,23 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         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)
+        cycleControl.taskLabel = ticketDisplaySlug(ticket) || String(ticket.title || 'the task').slice(0, 160)
         const typeSets = await taskTypeSets(activeTaskRef.projectId)
         if (blockedTasks.has(`${activeTaskRef.projectId}:${activeTaskRef.ticketId}`) ||
             !taskBelongsToAgent(ticket, { id: selfAgentId, identifier }) ||
             taskIsCompleted(ticket, typeSets.done) || taskIsAwaitingReview(ticket, typeSets.review)) {
           releaseTaskForRetry(activeTaskRef, prompt)
+          cycleControl.outcome = 'skipped'
           log('queued ticket no longer actionable; skipped before model start')
           return
         }
       }
       if (cycleControl.cancelled) return
+      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)
+      await cycleControl.planDelivery
       cycleControl.outcome = result?.is_error ? 'error' : result?.subtype || 'error'
       if (result?.timings) log(`cycle timing runtime=${JSON.stringify(result.timings)} kind=${kind}`)
       refreshModelSettings()
@@ -1584,6 +1675,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         return
       }
       if (!cycleSucceeded(result)) {
+        if (kind === 'full' && interruptedRuntimeResult(result) && cycleControl.attempt <= recoveryDelays.length) return { ...result, transportInterrupted: true }
         const outcome = result?.subtype || 'an unknown runtime error'
         const notice = `I'm blocked because the ${kind === 'full' ? 'coding' : 'reply'} cycle ended with ${outcome}.${result?.subtype === 'rate_limited' ? ` The model provider is rate-limiting this request. Choose a model with available quota in Agent Studio, or retry once the limit resets.\n\n[Open Agent Studio](http://127.0.0.1:4317/#agent=${encodeURIComponent(identifier)}&settings=1)\n\n` : ' '}I'm not claiming completion.${activeTaskRef ? " I've paused this revision until the ticket changes." : ''}`
         log('WORK_CYCLE_BLOCKED ' + outcome + '; publishing blocker')
@@ -1640,6 +1732,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         }
       }
     } finally {
+      activity.clear(cycleControl.cycleId)
       cycleControl.statusTargets.clear()
     }
   }
@@ -1702,6 +1795,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         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
+            item.control.wakeRecovery?.()
             void item.control.runner?.cancelCurrent?.()
           })
         }
@@ -1870,10 +1964,10 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       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.
+      // 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') => cid != null
-        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, sourceMessageId: mid, watcherOwned: agent === 'codex' }
+        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, sourceMessageId: mid, watcherOwned: true }
         : null
       // Under-the-hood model control from chat (view / switch the model the agent runs).
       const mcmd = cid != null ? parseModelCmd(text) : null
@@ -1958,7 +2052,19 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   // recover channel mentions even when the backend omits targeted dispatch.
   // Both event types share recipient, ownership and deduplication guards.
   log('up — backend WS watcher on ' + wsUrl + (canCode ? ' [code: ' + workdir + ']' : ''))
-  handle = (dependencies.connect || connectAgentWs)({ wsUrl, apiKey, identifier, onEvent, onConnect: () => { if (autoStart) setTimeout(() => { if (!stopping) void reconcileBacklog() }, 250) }, log })
+  handle = (dependencies.connect || connectAgentWs)({ wsUrl, apiKey, identifier, onEvent,
+    onDisconnect: () => {
+      eventConnection = 'disconnected'
+      emit('connection.disconnected', { status: 'disconnected', reason: 'Event connection lost; accepted work remains running' })
+    },
+    onConnect: () => {
+      if (stopping) return
+      eventConnection = 'connected'
+      activity.pulse()
+      emit('connection.connected', { status: 'connected' })
+      for (const wake of [...recoveryWaiters]) wake()
+      if (autoStart) setTimeout(() => { if (!stopping) void reconcileBacklog() }, 250)
+    }, log })
 
   let authorizationProbeBusy = false
   const legacyAuthorizationChecks = new Set()
@@ -1999,7 +2105,14 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   const modelSettingsTimer = autoStart ? setInterval(refreshModelSettings, 2_000) : null
   modelSettingsTimer?.unref?.()
   emit('models.updated', { model: codeModel, chatModel: liteModel, modelSettingsRevision })
-  const heartbeatTimer = autoStart ? setInterval(() => emit('watcher.heartbeat', { status: 'running', active: queues.work.activeSize + queues.reply.activeSize, pending: queues.work.size + queues.reply.size, model: codeModel, chatModel: liteModel, modelSettingsRevision, workdir: workdir || '' }), 15_000) : null
+  const heartbeatTimer = autoStart ? setInterval(() => {
+    emit('watcher.heartbeat', { status: 'running', active: queues.work.activeSize + queues.reply.activeSize, pending: queues.work.size + queues.reply.size, model: codeModel, chatModel: liteModel, modelSettingsRevision, workdir: workdir || '' })
+    // The Studio reads a bounded journal tail. Re-state current queue ownership
+    // so a long-running cycle stays visible after its start event rotates out.
+    for (const { data, control } of liveCycles.values()) {
+      if (!control.cancelled) emit('cycle.snapshot', { ...data, status: control.outcome, attempt: control.attempt || 1 })
+    }
+  }, 15_000) : null
   heartbeatTimer?.unref?.()
   let introTimer = null, taskProbeStartTimer = null, taskProbeTimer = null
   if (autoStart && (mcpConfig || mcpUrl)) {
@@ -2039,12 +2152,13 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       if (taskProbeTimer) clearInterval(taskProbeTimer)
       try { handle?.close() } catch { /* already disconnected */ }
       for (const queue of Object.values(queues)) {
-        queue.cancel(() => true, (item) => { item.control.cancelled = true })
+        queue.cancel(() => true, (item) => { item.control.cancelled = true; item.control.wakeRecovery?.() })
       }
       await Promise.allSettled([...activeReplyRunners, ...activeWorkRunners].map((runner) => Promise.resolve().then(() => runner.cancelCurrent?.())))
       await Promise.allSettled([...mentionIntake.values(), ...Object.values(queues).map((queue) => queue.settled()), ...messageDeliveries.values(), ...pendingOperations])
       workRunners.close()
       replyRunners.close()
+      await activity.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)) }

package/src/ws.mjs

@@ -37,7 +37,7 @@ export function assertWebSocket(fail) {
  * @param {(kind: string, payload: any) => void} o.onEvent  targeted dispatch.
  * @param {(msg: string) => void} o.log
  */
-export function connectAgentWs({ wsUrl, apiKey, identifier, onEvent, onConnect, log }) {
+export function connectAgentWs({ wsUrl, apiKey, identifier, onEvent, onConnect, onDisconnect, log }) {
   const base = stripSlash(wsUrl)
   const url = `${base}?api_key=${encodeURIComponent(apiKey)}&identifier=${encodeURIComponent(identifier)}`
 
@@ -96,10 +96,11 @@ export function connectAgentWs({ wsUrl, apiKey, identifier, onEvent, onConnect,
     })
 
     const down = (why) => {
-      if (sock !== ws) return
+      if (closed || sock !== ws) return
       clearKeepalive()
       ws = null
       log(why)
+      try { onDisconnect?.() } catch { /* connection telemetry is optional */ }
       scheduleReconnect()
     }
     // $connect 401 (bad/inactive credentials) surfaces as an immediate close.

package/studio/app.mjs

@@ -82,7 +82,7 @@ export function deriveModel(input) {
       if (event.type.startsWith('cycle.')) {
         if (data.kind != null) cycle.data.kind = data.kind;
         cycle.status = eventStatus(event);
-        if (event.type === 'cycle.started') cycle.startedAt = event.timestamp;
+        if (event.type === 'cycle.started') cycle.startedAt ||= event.timestamp;
         if (terminalStatuses.has(cycle.status)) cycle.finishedAt = event.timestamp;
       }
       if (event.type.startsWith('tool.')) {

package/studio/style.css

@@ -45,6 +45,8 @@
   button:disabled { cursor: default; opacity: .6; }
   button, a, input, select, summary { touch-action: manipulation; }
   :focus-visible { outline: 2px solid var(--focus); outline-offset: 3px; }
+  input:focus, select:focus, textarea:focus { outline: none; }
+  input:focus-visible, select:focus-visible, textarea:focus-visible { box-shadow: inset 0 -2px 0 var(--focus); }
   button, select, a { transition: background-color .16s ease-out, color .16s ease-out, box-shadow .16s ease-out; }
   h1, h2, h3, h4, p { margin: 0; }
   h1, h2, h3, h4, strong { font-weight: 500; }
@@ -76,7 +78,7 @@
   .count { font-size: 12px; background: var(--stage); min-width: 22px; height: 19px; display: grid; place-items: center; border-radius: 999px; font-variant-numeric: tabular-nums; }
   .agent-search { display: flex; align-items: center; gap: 7px; padding: 8px 10px; margin: 0 0 12px; color: var(--subtle); }
   .agent-search .icon { width: 14px; height: 14px; }
-  .agent-search input { width: 100%; border: 0; outline-offset: 5px; background: transparent; font-size: 12px; }
+  .agent-search input { width: 100%; border: 0; background: transparent; font-size: 12px; }
   .agent-list { display: flex; flex-direction: column; gap: 5px; }
   .agent-item { display: flex; align-items: center; gap: 10px; width: 100%; text-align: left; border: 0; background: transparent; padding: 10px; border-radius: var(--radius-md); corner-shape: squircle; }
   .agent-item:hover { background: var(--hover); }
@@ -123,7 +125,7 @@
   .filters { display: flex; gap: 9px; margin-bottom: 19px; }
   .search-field { flex: 1; min-width: 90px; display: flex; align-items: center; gap: 9px; border: 1px solid var(--border); border-radius: 999px; padding: 8px 12px; color: var(--subtle); }
   .search-field .icon { width: 14px; height: 14px; }
-  .search-field input { width: 100%; background: transparent; border: 0; font-size: 12px; outline-offset: 4px; }
+  .search-field input { width: 100%; background: transparent; border: 0; font-size: 12px; }
   .select-field { display: inline-flex; align-items: center; min-width: 108px; }
   .select-field select { width: 100%; min-height: 40px; padding: 7px 26px 7px 12px; border: 1px solid var(--border); border-radius: 999px; background-color: var(--surface); font-size: 12px; }
   .content-grid { display: grid; grid-template-columns: minmax(280px, .85fr) minmax(360px, 1.15fr); gap: 14px; align-items: start; }
@@ -360,7 +362,6 @@
   .model-settings-form label { display: grid; gap: 4px; font-size: 13px; margin-top: 8px; }
   .model-settings-form label span { font-size: 12px; color: var(--muted); }
   .model-settings-form input { width: 100%; min-width: 0; padding: 11px 14px; border: 1px solid var(--border); border-radius: 18px; background: transparent; color: var(--ink); font-size: 13px; }
-  .model-settings-form input:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; }
   .model-settings-actions { display: flex; flex-wrap: wrap; justify-content: space-between; gap: 12px; margin-top: 8px; }
   #model-settings-error { color: #9f3030; }
   @media (max-width: 640px) {