openvisio-agent 0.22.0 → 0.24.0

package/src/watch.mjs

@@ -15,10 +15,15 @@ import { connectAgentWs, assertWebSocket } from './ws.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'
 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'
@@ -76,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.',
@@ -137,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.',
@@ -149,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) ───────────────────
@@ -164,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')
@@ -330,16 +337,18 @@ 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, workspaceAvailable = !!workdir }) {
+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, workspaceAvailable, 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 = {}
+  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.
@@ -424,6 +433,8 @@ 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)
     }
@@ -503,7 +514,14 @@ export function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, m
       : ' [CONTEXT session — advertised tools, reading, search, and planning]'))
   }
 
-  function runCycle(prompt, cycleModel, cycleOptions = {}) {
+  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
@@ -591,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 || '' })
@@ -598,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.
@@ -612,13 +644,17 @@ 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
   // runtimes. Replies serialize within a thread while independent threads run
   // concurrently behind the same delivery guards.
   const MAX_CONCURRENT_WORKERS = 3
   const activeWorkRunners = new Set()
+  const recoveryWaiters = new Set()
+  const recoveryDelays = dependencies.transportRecoveryDelays || transportRecoveryDelays
+  let eventConnection = 'unknown'
   const createWorkRunner = (control, workerWorkdir = '') => makeRunner({
     ...runnerOptions,
     ...(workerWorkdir ? { workdir: workerWorkdir } : {}),
@@ -640,12 +676,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 = '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.'
+  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. 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.
@@ -674,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) => {
@@ -721,6 +757,13 @@ 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.
@@ -729,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 : [])
@@ -856,6 +899,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' })
@@ -1015,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')
       })
@@ -1043,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) {
@@ -1060,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)
@@ -1079,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()
@@ -1104,6 +1151,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 } })
@@ -1117,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
@@ -1473,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] : []
@@ -1495,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)
@@ -1523,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.
@@ -1532,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()
@@ -1568,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')
@@ -1624,6 +1732,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         }
       }
     } finally {
+      activity.clear(cycleControl.cycleId)
       cycleControl.statusTargets.clear()
     }
   }
@@ -1686,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?.()
           })
         }
@@ -1851,11 +1961,13 @@ 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.
+      // 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
@@ -1940,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()
@@ -1981,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)) {
@@ -2021,12 +2152,14 @@ 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)) }
       finally {

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/guide.html

@@ -21,6 +21,7 @@
           <a href="#start">Open Studio</a>
           <a href="#watchers">Show your agents</a>
           <a href="#find-work">Find and inspect work</a>
+          <a href="#recall">Tasks and conversation recall</a>
           <a href="#statuses">Understand statuses</a>
           <a href="#controls">Pause and follow</a>
           <a href="#models">Change models</a>
@@ -71,6 +72,12 @@
             <p><strong>No explicit plan recorded</strong> means the provider did not send a plan in the available history. A missing process ID means the provider did not report that operating-system identifier. Neither message alone means the work failed.</p>
             <p>The process summary counts distinct reported process IDs associated with connected watchers. It is not a system-wide process monitor. The demo deliberately shows no real process count.</p>
           </section>
+          <section id="recall">
+            <h2>Tasks and conversation recall</h2>
+            <p>Tell your agent “I have a task for you” or ask it to check its assignments. The agent has a live task lookup, a searchable tool guide, and short skills it can load when helpful. A lookup does not itself claim, start, or complete a task.</p>
+            <p>Ask about an earlier decision, such as “What did we decide about credential storage?” The agent can search recorded conversations by meaning and return to the original channel or thread for verification. It searches messages it has observed or fetched, so conversations it has never read may be missing.</p>
+            <p>The first semantic search downloads a local embedding model. Keyword search stays available while it loads. Later inference runs on this computer without an embedding API key. The agent chooses what context to retrieve and when to end its turn.</p>
+          </section>
           <section id="statuses">
             <h2>Understand statuses</h2>
             <dl>

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) {