@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/chat-execution.ts

@@ -1,5 +1,6 @@
 import fs from 'fs'
 import os from 'os'
+import path from 'path'
 import {
   loadSessions,
   saveSessions,
@@ -27,6 +28,7 @@ import { getPluginManager } from './plugins'
 import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
 import { routeTaskIntent } from './capability-router'
 import { notify } from './ws-hub'
+import { applyResolvedRoute, resolvePrimaryAgentRoute } from './agent-runtime-config'
 import { resolveConcreteToolPolicyBlock, resolveSessionToolPolicy } from './tool-capability-policy'
 import { pluginIdMatches } from './tool-aliases'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
@@ -38,7 +40,12 @@ import {
 } from './llm-response-cache'
 import type { Message, MessageToolEvent, SSEEvent, UsageRecord } from '@/types'
 import { markProviderFailure, markProviderSuccess, rankDelegatesByHealth } from './provider-health'
+import { isHeartbeatSource, isInternalHeartbeatRun } from './heartbeat-source'
 import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
+import { buildIdentityContinuityContext, refreshSessionIdentityState } from './identity-continuity'
+import { syncSessionArchiveMemory } from './session-archive-memory'
+import { evaluateSessionFreshness, resetSessionRuntime, resolveSessionResetPolicy } from './session-reset-policy'
+import { pruneStreamingAssistantArtifacts, upsertStreamingAssistantArtifact } from '@/lib/chat-streaming-state'
 type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli' | 'delegate_to_gemini_cli'
 
 /** Slice history from the most recent context-clear marker forward */
@@ -92,6 +99,10 @@ export interface ExecuteChatTurnResult {
   estimatedCost?: number
 }
 
+export function shouldApplySessionFreshnessReset(source: string): boolean {
+  return source !== 'eval'
+}
+
 function extractEventJson(line: string): SSEEvent | null {
   if (!line.startsWith('data: ')) return null
   try {
@@ -101,8 +112,17 @@ function extractEventJson(line: string): SSEEvent | null {
   }
 }
 
-function collectToolEvent(ev: SSEEvent, bag: MessageToolEvent[]) {
+export function collectToolEvent(ev: SSEEvent, bag: MessageToolEvent[]) {
   if (ev.t === 'tool_call') {
+    const previous = bag[bag.length - 1]
+    if (
+      previous
+      && previous.name === (ev.toolName || 'unknown')
+      && previous.input === (ev.toolInput || '')
+      && !previous.output
+    ) {
+      return
+    }
     bag.push({
       name: ev.toolName || 'unknown',
       input: ev.toolInput || '',
@@ -113,15 +133,210 @@ function collectToolEvent(ev: SSEEvent, bag: MessageToolEvent[]) {
     const idx = bag.findLastIndex((e) => e.name === (ev.toolName || 'unknown') && !e.output)
     if (idx === -1) return
     const output = ev.toolOutput || ''
-    const isError = /^(Error:|error:)/i.test(output.trim())
-      || output.includes('ECONNREFUSED')
-      || output.includes('ETIMEDOUT')
-      || output.includes('Error:')
     bag[idx] = {
       ...bag[idx],
       output,
-      error: isError || undefined,
+      error: isLikelyToolErrorOutput(output) || undefined,
+    }
+  }
+}
+
+export function dedupeConsecutiveToolEvents(events: MessageToolEvent[]): MessageToolEvent[] {
+  const sameEvent = (left: MessageToolEvent, right: MessageToolEvent): boolean => (
+    left.name === right.name
+    && left.input === right.input
+    && (left.output || '') === (right.output || '')
+    && (left.error === true) === (right.error === true)
+  )
+  const sameBlock = (startA: number, startB: number, size: number): boolean => {
+    for (let offset = 0; offset < size; offset += 1) {
+      if (!sameEvent(events[startA + offset], events[startB + offset])) return false
+    }
+    return true
+  }
+
+  const deduped: MessageToolEvent[] = []
+  for (let index = 0; index < events.length;) {
+    const remaining = events.length - index
+    let collapsed = false
+    for (let blockSize = Math.floor(remaining / 2); blockSize >= 1; blockSize -= 1) {
+      if (!sameBlock(index, index + blockSize, blockSize)) continue
+      for (let offset = 0; offset < blockSize; offset += 1) deduped.push(events[index + offset])
+      const blockStart = index
+      index += blockSize
+      while (index + blockSize <= events.length && sameBlock(blockStart, index, blockSize)) {
+        index += blockSize
+      }
+      collapsed = true
+      break
+    }
+    if (collapsed) continue
+    deduped.push(events[index])
+    index += 1
+  }
+  return deduped
+}
+
+function extractDelegateResponse(outputText: string): string | null {
+  try {
+    const parsed = JSON.parse(outputText) as Record<string, unknown>
+    if (typeof parsed.response === 'string' && parsed.response.trim()) return parsed.response.trim()
+    if (typeof parsed.result === 'string' && parsed.result.trim()) return parsed.result.trim()
+    return null
+  } catch {
+    return null
+  }
+}
+
+const MANAGE_PLATFORM_RESOURCE_TO_TOOL: Record<string, string> = {
+  agent: 'manage_agents',
+  agents: 'manage_agents',
+  task: 'manage_tasks',
+  tasks: 'manage_tasks',
+  schedule: 'manage_schedules',
+  schedules: 'manage_schedules',
+  skill: 'manage_skills',
+  skills: 'manage_skills',
+  document: 'manage_documents',
+  documents: 'manage_documents',
+  secret: 'manage_secrets',
+  secrets: 'manage_secrets',
+  connector: 'manage_connectors',
+  connectors: 'manage_connectors',
+  session: 'manage_sessions',
+  sessions: 'manage_sessions',
+}
+
+export function translateRequestedToolInvocation(
+  requestedName: string,
+  rawArgs: Record<string, unknown>,
+  messageFallback: string,
+  availableToolNames?: Iterable<string>,
+): { toolName: string; args: Record<string, unknown> } {
+  const available = new Set(availableToolNames || [])
+
+  if (requestedName === 'web_search') {
+    return {
+      toolName: 'web',
+      args: {
+        action: 'search',
+        query: typeof rawArgs.query === 'string' ? rawArgs.query : messageFallback.trim(),
+        maxResults: typeof rawArgs.maxResults === 'number' ? rawArgs.maxResults : 5,
+      },
+    }
+  }
+  if (requestedName === 'web_fetch') {
+    return {
+      toolName: 'web',
+      args: {
+        action: 'fetch',
+        url: rawArgs.url,
+      },
+    }
+  }
+  if (requestedName === 'delegate_to_claude_code') {
+    return { toolName: 'delegate', args: { ...rawArgs, backend: 'claude' } }
+  }
+  if (requestedName === 'delegate_to_codex_cli') {
+    return { toolName: 'delegate', args: { ...rawArgs, backend: 'codex' } }
+  }
+  if (requestedName === 'delegate_to_opencode_cli') {
+    return { toolName: 'delegate', args: { ...rawArgs, backend: 'opencode' } }
+  }
+  if (requestedName === 'delegate_to_gemini_cli') {
+    return { toolName: 'delegate', args: { ...rawArgs, backend: 'gemini' } }
+  }
+
+  const managePrefix = 'manage_'
+  if (requestedName === 'manage_platform') {
+    const resource = typeof rawArgs.resource === 'string'
+      ? rawArgs.resource.trim().toLowerCase()
+      : ''
+    const specificTool = MANAGE_PLATFORM_RESOURCE_TO_TOOL[resource]
+    if (specificTool && available.has(specificTool) && !available.has('manage_platform')) {
+      return { toolName: specificTool, args: rawArgs }
     }
+    return { toolName: requestedName, args: rawArgs }
+  }
+
+  if (requestedName.startsWith(managePrefix) && requestedName !== 'manage_platform') {
+    if (!available.has(requestedName) && available.has('manage_platform')) {
+      const resource = requestedName.slice(managePrefix.length)
+      if (resource) {
+        const { action, id, data, ...rest } = rawArgs
+        const nextArgs: Record<string, unknown> = { resource, ...rest }
+        if (action !== undefined) nextArgs.action = action
+        if (id !== undefined) nextArgs.id = id
+        if (data !== undefined) nextArgs.data = data
+        return {
+          toolName: 'manage_platform',
+          args: nextArgs,
+        }
+      }
+    }
+    return { toolName: requestedName, args: rawArgs }
+  }
+
+  return { toolName: requestedName, args: rawArgs }
+}
+
+export function isLikelyToolErrorOutput(output: string): boolean {
+  const trimmed = String(output || '').trim()
+  if (!trimmed) return false
+  if (/^(Error(?::|\s*\(exit\b[^)]*\):?)|error:)/i.test(trimmed)) return true
+  if (/\b(MCP error|ECONNREFUSED|ETIMEDOUT|ERR_CONNECTION_REFUSED|ENOENT|EACCES)\b/i.test(trimmed)) return true
+  if (/\binvalid_type\b/i.test(trimmed) && /\b(issue|issues|expected|required|received|zod)\b/i.test(trimmed)) return true
+  try {
+    const parsed = JSON.parse(trimmed) as Record<string, unknown>
+    const status = typeof parsed.status === 'string' ? parsed.status.trim().toLowerCase() : ''
+    if (status === 'error' || status === 'failed') return true
+    if (typeof parsed.error === 'string' && parsed.error.trim()) return true
+  } catch {
+    // Ignore non-JSON tool output.
+  }
+  return false
+}
+
+function normalizeWorkspaceSandboxLinks(text: string, cwd: string): string {
+  return text.replace(/\[([^\]]+)\]\(sandbox:\/workspace\/([^)]+)\)/g, (raw, label: string, relativePath: string) => {
+    const normalized = String(relativePath || '').replace(/^\/+/, '')
+    if (!normalized) return raw
+    const resolvedCwd = path.resolve(cwd)
+    const resolved = path.resolve(resolvedCwd, normalized)
+    if (!resolved.startsWith(resolvedCwd)) return raw
+    if (!fs.existsSync(resolved)) return raw
+    return `[${label}](/api/files/serve?path=${encodeURIComponent(resolved)})`
+  })
+}
+
+function normalizeAbsoluteFileMarkdownLinks(text: string): string {
+  return text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (raw, label: string, target: string) => {
+    if (!path.isAbsolute(target)) return raw
+    const resolved = path.resolve(target)
+    if (!fs.existsSync(resolved)) return raw
+    return `[${label}](/api/files/serve?path=${encodeURIComponent(resolved)})`
+  })
+}
+
+export function normalizeAssistantArtifactLinks(text: string, cwd: string): string {
+  const uploadsNormalized = text.replace(/sandbox:\/api\/uploads\//g, '/api/uploads/')
+  const workspaceNormalized = normalizeWorkspaceSandboxLinks(uploadsNormalized, cwd)
+  return normalizeAbsoluteFileMarkdownLinks(workspaceNormalized)
+}
+
+function extractHeartbeatStatus(text: string): { goal?: string; status?: string; summary?: string; nextAction?: string } | null {
+  const match = text.match(/\[AGENT_HEARTBEAT_META\]\s*(\{[^\n]*\})/i)
+  if (!match) return null
+  try {
+    const meta = JSON.parse(match[1]) as Record<string, unknown>
+    const payload: { goal?: string; status?: string; summary?: string; nextAction?: string } = {}
+    if (typeof meta.goal === 'string' && meta.goal.trim()) payload.goal = meta.goal.trim()
+    if (typeof meta.status === 'string' && meta.status.trim()) payload.status = meta.status.trim()
+    if (typeof meta.summary === 'string' && meta.summary.trim()) payload.summary = meta.summary.trim()
+    if (typeof meta.next_action === 'string' && meta.next_action.trim()) payload.nextAction = meta.next_action.trim()
+    return Object.keys(payload).length > 0 ? payload : null
+  } catch {
+    return null
   }
 }
 
@@ -140,7 +355,11 @@ function shouldReplaceRecentAssistantMessage(params: {
   return prevTools === 0
 }
 
-function requestedToolNamesFromMessage(message: string): string[] {
+export function pruneSuppressedHeartbeatStreamMessage(messages: Message[]): boolean {
+  return pruneStreamingAssistantArtifacts(messages)
+}
+
+export function requestedToolNamesFromMessage(message: string): string[] {
   const lower = message.toLowerCase()
   const candidates = [
     'delegate_to_claude_code',
@@ -179,15 +398,24 @@ function requestedToolNamesFromMessage(message: string): string[] {
     'sandbox_list_runtimes',
     'git',
     'canvas',
-    'delegate',
     'schedule_wake',
     'spawn_subagent',
+    'mailbox',
+    'ask_human',
+    'document',
+    'extract',
+    'table',
+    'crawl',
     'context_status',
     'context_summarize',
     'openclaw_nodes',
     'openclaw_workspace',
   ]
-  return candidates.filter((name) => lower.includes(name.toLowerCase()))
+  const requested = candidates.filter((name) => lower.includes(name.toLowerCase()))
+  if (/(^|[\s(])`delegate`([\s).,!?]|$)|\bdelegate tool\b|\buse delegate\b/.test(lower)) {
+    requested.push('delegate')
+  }
+  return Array.from(new Set(requested))
 }
 
 function parseKeyValueArgs(raw: string): Record<string, string> {
@@ -398,17 +626,51 @@ function syncSessionFromAgent(sessionId: string): void {
   if (!agent) return
 
   let changed = false
-  if (agent.provider && agent.provider !== session.provider) { session.provider = agent.provider; changed = true }
-  if (agent.model !== undefined && agent.model !== session.model) { session.model = agent.model; changed = true }
-  if (agent.credentialId !== undefined && agent.credentialId !== session.credentialId) { session.credentialId = agent.credentialId ?? null; changed = true }
-  if (agent.apiEndpoint !== undefined) {
-    const normalized = normalizeProviderEndpoint(agent.provider, agent.apiEndpoint ?? null)
-    if (normalized !== session.apiEndpoint) { session.apiEndpoint = normalized; changed = true }
+  const route = resolvePrimaryAgentRoute(agent)
+  if (!session.provider && agent.provider) { session.provider = agent.provider; changed = true }
+  if ((session.model === undefined || session.model === null || session.model === '') && agent.model !== undefined) {
+    session.model = agent.model
+    changed = true
+  }
+  if (route) {
+    const resolved = applyResolvedRoute({ ...session }, route)
+    if (session.provider !== resolved.provider) { session.provider = resolved.provider; changed = true }
+    if (session.model !== resolved.model) { session.model = resolved.model; changed = true }
+    if ((session.credentialId || null) !== (resolved.credentialId || null)) {
+      session.credentialId = resolved.credentialId ?? null
+      changed = true
+    }
+    if (JSON.stringify(session.fallbackCredentialIds || []) !== JSON.stringify(resolved.fallbackCredentialIds || [])) {
+      session.fallbackCredentialIds = [...resolved.fallbackCredentialIds]
+      changed = true
+    }
+    if ((session.apiEndpoint || null) !== (resolved.apiEndpoint || null)) {
+      session.apiEndpoint = resolved.apiEndpoint ?? null
+      changed = true
+    }
+    if ((session.gatewayProfileId || null) !== (resolved.gatewayProfileId || null)) {
+      session.gatewayProfileId = resolved.gatewayProfileId ?? null
+      changed = true
+    }
+  } else {
+    if (session.credentialId === undefined && agent.credentialId !== undefined) {
+      session.credentialId = agent.credentialId ?? null
+      changed = true
+    }
+    if ((session.apiEndpoint === undefined || session.apiEndpoint === null) && agent.apiEndpoint !== undefined) {
+      const normalized = normalizeProviderEndpoint(agent.provider, agent.apiEndpoint ?? null)
+      if (normalized !== session.apiEndpoint) { session.apiEndpoint = normalized; changed = true }
+    }
   }
   if (!Array.isArray(session.plugins)) {
     session.plugins = Array.isArray(agent.plugins) ? [...agent.plugins] : []
     changed = true
   }
+  const isShortcutChat = session.shortcutForAgentId === agent.id || agent.threadSessionId === sessionId
+  if (isShortcutChat) {
+    if (session.shortcutForAgentId !== agent.id) { session.shortcutForAgentId = agent.id; changed = true }
+    if (session.name !== agent.name) { session.name = agent.name; changed = true }
+  }
 
   if (changed) {
     sessions[sessionId] = session
@@ -435,6 +697,8 @@ function buildAgentSystemPrompt(session: Session): string | undefined {
   if (agent.description) identityLines.push(`Description: ${agent.description}`)
   identityLines.push('I should always embody this identity. I am not just an "Assistant" — I am a persistent companion with my own soul and presence.')
   parts.push(identityLines.join('\n'))
+  const continuityBlock = buildIdentityContinuityContext(session, agent)
+  if (continuityBlock) parts.push(continuityBlock)
 
   // 2. Runtime & Capabilities (OpenClaw Style)
   const runtimeLines = [
@@ -553,20 +817,56 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   const sessions = loadSessions()
   const session = sessions[sessionId]
   if (!session) throw new Error(`Session not found: ${sessionId}`)
+  session.messages = Array.isArray(session.messages) ? session.messages : []
+  const runStartedAt = Date.now()
+  const runMessageStartIndex = session.messages.length
 
   const appSettings = loadSettings()
+  const agentForSession = session.agentId ? loadAgents()[session.agentId] : null
   const toolPolicy = resolveSessionToolPolicy(session.plugins, appSettings)
-  const isHeartbeatRun = internal && source === 'heartbeat'
-  const isAutoRunNoHistory = isHeartbeatRun || (internal && source === 'main-loop-followup')
-  const heartbeatStatus = session.mainLoopState?.status || 'idle'
-  const mainLoopIdle = session.id.startsWith('agent-thread-')
-    && (heartbeatStatus === 'ok' || heartbeatStatus === 'idle')
-    && !(session.mainLoopState?.pendingEvents?.length > 0)
-  const heartbeatStatusOnly = isHeartbeatRun && mainLoopIdle
+  const isHeartbeatRun = isInternalHeartbeatRun(internal, source)
+  const isAutoRunNoHistory = isHeartbeatRun
+  const heartbeatStatusOnly = false
+  if (shouldApplySessionFreshnessReset(source)) {
+    const freshness = evaluateSessionFreshness({
+      session,
+      policy: resolveSessionResetPolicy({
+        session,
+        agent: agentForSession,
+        settings: appSettings,
+      }),
+    })
+    if (!freshness.fresh) {
+      try { syncSessionArchiveMemory(session, { agent: agentForSession }) } catch { /* archive sync is best-effort */ }
+      resetSessionRuntime(session, freshness.reason || 'session_reset')
+      onEvent?.({ t: 'status', text: JSON.stringify({ sessionReset: freshness.reason || 'session_reset' }) })
+      sessions[sessionId] = session
+      saveSessions(sessions)
+    }
+  }
   const pluginsForRun = heartbeatStatusOnly ? [] : toolPolicy.enabledPlugins
   let sessionForRun = pluginsForRun === session.plugins
     ? session
     : { ...session, plugins: pluginsForRun }
+  if (agentForSession) {
+    const preferredRoute = resolvePrimaryAgentRoute(agentForSession)
+    if (preferredRoute) {
+      sessionForRun = applyResolvedRoute({ ...sessionForRun }, preferredRoute)
+    }
+  }
+  let effectiveMessage = message
+
+  if (pluginsForRun.length > 0) {
+    try {
+      effectiveMessage = await getPluginManager().transformText(
+        'transformInboundMessage',
+        { session: sessionForRun, text: message },
+        { enabledIds: pluginsForRun },
+      )
+    } catch {
+      effectiveMessage = message
+    }
+  }
 
   // Apply model override for heartbeat runs (cheaper model)
   if (isHeartbeatRun && input.modelOverride) {
@@ -660,14 +960,14 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     detail: {
       source,
       internal,
-      provider: session.provider,
-      model: session.model,
-      messagePreview: message.slice(0, 200),
+      provider: sessionForRun.provider,
+      model: sessionForRun.model,
+      messagePreview: effectiveMessage.slice(0, 200),
       hasImage: !!(imagePath || imageUrl),
     },
   })
 
-  const providerType = session.provider || 'claude-cli'
+  const providerType = sessionForRun.provider || 'claude-cli'
   const provider = getProvider(providerType)
   if (!provider) throw new Error(`Unknown provider: ${providerType}`)
 
@@ -675,11 +975,11 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     throw new Error(`Directory not found: ${session.cwd}`)
   }
 
-  const apiKey = resolveApiKeyForSession(session, provider)
+  const apiKey = resolveApiKeyForSession(sessionForRun, provider)
 
   if (!internal) {
     const linkAnalysis = await runLinkUnderstanding(message)
-    session.messages.push({
+    const nextUserMessage: Message = {
       role: 'user',
       text: message,
       time: Date.now(),
@@ -687,7 +987,8 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       imageUrl: imageUrl || undefined,
       attachedFiles: attachedFiles?.length ? attachedFiles : undefined,
       replyToId: input.replyToId || undefined,
-    })
+    }
+    session.messages.push(nextUserMessage)
     if (linkAnalysis.length > 0) {
       session.messages.push({
         role: 'assistant',
@@ -698,6 +999,9 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     }
     session.lastActiveAt = Date.now()
     saveSessions(sessions)
+    try {
+      await getPluginManager().runHook('onMessage', { session, message: nextUserMessage }, { enabledIds: pluginsForRun })
+    } catch { /* onMessage hooks are non-critical */ }
   }
 
   const systemPrompt = buildAgentSystemPrompt(session)
@@ -746,19 +1050,18 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         const fresh = loadSessions()
         const current = fresh[sessionId]
         if (!current) return
+        current.messages = Array.isArray(current.messages) ? current.messages : []
         const partialMsg: Message = {
           role: 'assistant',
           text: streamingPartialText,
           time: Date.now(),
           streaming: true,
-          toolEvents: toolEvents.length ? [...toolEvents] : undefined,
-        }
-        const lastMsg = current.messages.at(-1)
-        if (lastMsg?.streaming) {
-          current.messages[current.messages.length - 1] = partialMsg
-        } else {
-          current.messages.push(partialMsg)
+          toolEvents: toolEvents.length ? dedupeConsecutiveToolEvents([...toolEvents]) : undefined,
         }
+        upsertStreamingAssistantArtifact(current.messages, partialMsg, {
+          minIndex: runMessageStartIndex,
+          minTime: runStartedAt,
+        })
         fresh[sessionId] = current
         saveSessions(fresh)
         notify(`messages:${sessionId}`)
@@ -812,7 +1115,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     if (hasPlugins) {
       fullResponse = (await streamAgentChat({
         session: sessionForRun,
-        message: message,
+        message: effectiveMessage,
         imagePath,
         attachedFiles,
         apiKey,
@@ -830,7 +1133,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         model: sessionForRun.model,
         apiEndpoint: sessionForRun.apiEndpoint || '',
         systemPrompt,
-        message: message,
+        message: effectiveMessage,
         imagePath,
         imageUrl,
         attachedFiles,
@@ -858,7 +1161,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       } else {
         fullResponse = await provider.handler.streamChat({
           session: sessionForRun,
-          message: message,
+          message: effectiveMessage,
           imagePath,
           apiKey,
           systemPrompt,
@@ -937,57 +1240,6 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     : null
   const calledNames = new Set((toolEvents || []).map((t) => t.name))
 
-  const translateToolInvocation = (
-    requestedName: string,
-    rawArgs: Record<string, unknown>,
-  ): { toolName: string; args: Record<string, unknown> } => {
-    if (requestedName === 'web_search') {
-      return {
-        toolName: 'web',
-        args: {
-          action: 'search',
-          query: typeof rawArgs.query === 'string' ? rawArgs.query : message.trim(),
-          maxResults: typeof rawArgs.maxResults === 'number' ? rawArgs.maxResults : 5,
-        },
-      }
-    }
-    if (requestedName === 'web_fetch') {
-      return {
-        toolName: 'web',
-        args: {
-          action: 'fetch',
-          url: rawArgs.url,
-        },
-      }
-    }
-    if (requestedName === 'delegate_to_claude_code') {
-      return { toolName: 'delegate', args: { ...rawArgs, backend: 'claude' } }
-    }
-    if (requestedName === 'delegate_to_codex_cli') {
-      return { toolName: 'delegate', args: { ...rawArgs, backend: 'codex' } }
-    }
-    if (requestedName === 'delegate_to_opencode_cli') {
-      return { toolName: 'delegate', args: { ...rawArgs, backend: 'opencode' } }
-    }
-    if (requestedName === 'delegate_to_gemini_cli') {
-      return { toolName: 'delegate', args: { ...rawArgs, backend: 'gemini' } }
-    }
-
-    const managePrefix = 'manage_'
-    if (requestedName.startsWith(managePrefix) && requestedName !== 'manage_platform') {
-      const resource = requestedName.slice(managePrefix.length)
-      if (resource) {
-        const { action, id, data, ...rest } = rawArgs
-        return {
-          toolName: 'manage_platform',
-          args: { resource, action, id, data, ...rest },
-        }
-      }
-    }
-
-    return { toolName: requestedName, args: rawArgs }
-  }
-
   const invokeSessionTool = async (toolName: string, args: Record<string, unknown>, failurePrefix: string): Promise<boolean> => {
     const blockedReason = resolveConcreteToolPolicyBlock(toolName, toolPolicy, appSettings)
     if (blockedReason) {
@@ -1011,18 +1263,28 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       mcpDisabledTools: agent?.mcpDisabledTools,
     })
     try {
-      const translated = translateToolInvocation(toolName, args)
-      const selectedTool = tools.find((t) => t?.name === translated.toolName) as StructuredToolInterface | undefined
+      const directTool = tools.find((t) => t?.name === toolName) as StructuredToolInterface | undefined
+      const availableToolNames = tools.map((candidate) => candidate?.name).filter(Boolean)
+      const translated = directTool
+        ? { toolName, args }
+        : translateRequestedToolInvocation(toolName, args, message, availableToolNames)
+      const selectedTool = directTool || tools.find((t) => t?.name === translated.toolName) as StructuredToolInterface | undefined
       if (!selectedTool?.invoke) return false
       const toolInput = JSON.stringify(translated.args)
       emit({ t: 'tool_call', toolName, toolInput })
       const toolOutput = await selectedTool.invoke(translated.args)
       const outputText = typeof toolOutput === 'string' ? toolOutput : JSON.stringify(toolOutput)
       emit({ t: 'tool_result', toolName, toolOutput: outputText })
-      // Don't overwrite fullResponse with raw tool output — it's already captured
-      // in toolEvents. Only set a brief notice when the LLM produced no text,
-      // so the message bubble isn't empty.
-      if (!fullResponse.trim() && outputText?.trim()) {
+      const delegateResponse = (
+        toolName === 'delegate'
+        || toolName.startsWith('delegate_to_')
+      ) ? extractDelegateResponse(outputText) : null
+      if (delegateResponse) {
+        fullResponse = delegateResponse
+      } else if (!fullResponse.trim() && outputText?.trim()) {
+        // Don't overwrite fullResponse with raw tool output — it's already captured
+        // in toolEvents. Only set a brief notice when the LLM produced no text,
+        // so the message bubble isn't empty.
         const label = toolName.replace(/_/g, ' ')
         fullResponse = `Used **${label}** — see tool output above for details.`
       }
@@ -1075,7 +1337,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     const delegationOrder = rankDelegatesByHealth(baseDelegationOrder as DelegateTool[])
       .filter((tool) => enabledDelegateTools.includes(tool))
     for (const delegateTool of delegationOrder) {
-      const invoked = await invokeSessionTool(delegateTool, { task: message.trim() }, 'Auto-delegation failed')
+      const invoked = await invokeSessionTool(delegateTool, { task: effectiveMessage.trim() }, 'Auto-delegation failed')
       if (invoked) break
     }
   }
@@ -1095,7 +1357,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     for (const delegateTool of fallbackOrder) {
       const invoked = await invokeSessionTool(
         delegateTool,
-        { task: message.trim() },
+        { task: effectiveMessage.trim() },
         `Provider failover via ${delegateTool} failed`,
       )
       if (invoked) {
@@ -1113,7 +1375,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   if (canAutoRouteWithTools && routingDecision?.intent === 'browsing' && routingDecision.primaryUrl && hasToolEnabled(sessionForRun, 'browser')) {
     await invokeSessionTool(
       'browser',
-      { action: 'navigate', url: routingDecision.primaryUrl },
+      { action: 'read_page', url: routingDecision.primaryUrl },
       'Auto browser routing failed',
     )
   }
@@ -1123,7 +1385,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     if (routeUrl && hasToolEnabled(sessionForRun, 'web_fetch')) {
       await invokeSessionTool('web_fetch', { url: routeUrl }, 'Auto web_fetch routing failed')
     } else if (hasToolEnabled(sessionForRun, 'web_search')) {
-      await invokeSessionTool('web_search', { query: message.trim(), maxResults: 5 }, 'Auto web_search routing failed')
+      await invokeSessionTool('web_search', { query: effectiveMessage.trim(), maxResults: 5 }, 'Auto web_search routing failed')
     }
   }
 
@@ -1158,27 +1420,23 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     errorMessage = streamErrors[streamErrors.length - 1]
   }
 
-  const finalText = (fullResponse || '').trim() || (!internal && errorMessage ? `Error: ${errorMessage}` : '')
+  let finalText = (fullResponse || '').trim() || (!internal && errorMessage ? `Error: ${errorMessage}` : '')
+  if (pluginsForRun.length > 0 && finalText && !isHeartbeatRun) {
+    try {
+      finalText = await getPluginManager().transformText(
+        'transformOutboundMessage',
+        { session: sessionForRun, text: finalText },
+        { enabledIds: pluginsForRun },
+      )
+    } catch { /* outbound transforms are non-critical */ }
+  }
+  finalText = normalizeAssistantArtifactLinks(finalText, session.cwd)
   const textForPersistence = stripMainLoopMetaForPersistence(finalText)
+  const persistedToolEvents = dedupeConsecutiveToolEvents(toolEvents)
 
-  // Emit status SSE event from [MAIN_LOOP_META] if present
-  if (internal && finalText) {
-    const metaMatch = finalText.match(/\[MAIN_LOOP_META\]\s*(\{[^\n]*\})/i)
-    if (metaMatch) {
-      try {
-        const meta = JSON.parse(metaMatch[1])
-        const statusPayload: Record<string, string | undefined> = {}
-        if (meta.goal) statusPayload.goal = String(meta.goal)
-        if (meta.status) statusPayload.status = String(meta.status)
-        if (meta.summary) statusPayload.summary = String(meta.summary)
-        if (meta.next_action) statusPayload.nextAction = String(meta.next_action)
-        if (Object.keys(statusPayload).length > 0) {
-          emit({ t: 'status', text: JSON.stringify(statusPayload) })
-        }
-      } catch {
-        // ignore malformed meta JSON
-      }
-    }
+  if (isHeartbeatRun && finalText) {
+    const heartbeatStatus = extractHeartbeatStatus(finalText)
+    if (heartbeatStatus) emit({ t: 'status', text: JSON.stringify(heartbeatStatus) })
   }
 
   // HEARTBEAT_OK suppression
@@ -1214,7 +1472,13 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   const fresh = loadSessions()
   const current = fresh[sessionId]
   if (current) {
+    current.messages = Array.isArray(current.messages) ? current.messages : []
+    const currentAgent = current.agentId ? loadAgents()[current.agentId] : null
     let changed = false
+    changed = pruneStreamingAssistantArtifacts(current.messages, {
+      minIndex: runMessageStartIndex,
+      minTime: runStartedAt,
+    }) || changed
     const persistField = (key: string, value: unknown) => {
       const normalized = normalizeResumeId(value)
       if ((current as Record<string, unknown>)[key] !== normalized) {
@@ -1246,7 +1510,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     }
 
     if (shouldPersistAssistant) {
-      const persistedKind = internal && source === 'heartbeat' ? 'heartbeat' : 'chat'
+      const persistedKind = isHeartbeatRun ? 'heartbeat' : 'chat'
       const persistedText = heartbeatClassification === 'strip'
         ? textForPersistence.replace(/HEARTBEAT_OK/gi, '').trim()
         : textForPersistence
@@ -1256,13 +1520,13 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         text: persistedText,
         time: nowTs,
         thinking: thinkingText || undefined,
-        toolEvents: toolEvents.length ? toolEvents : undefined,
+        toolEvents: persistedToolEvents.length ? persistedToolEvents : undefined,
         kind: persistedKind,
       }
       const previous = current.messages.at(-1)
       if (previous?.streaming || shouldReplaceRecentAssistantMessage({
         previous,
-        nextToolEvents: toolEvents,
+        nextToolEvents: persistedToolEvents,
         nextKind: persistedKind,
         now: nowTs,
       })) {
@@ -1275,6 +1539,9 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         current.lastHeartbeatSentAt = nowTs
       }
       changed = true
+      try {
+        await getPluginManager().runHook('onMessage', { session: current, message: nextAssistantMessage }, { enabledIds: pluginsForRun })
+      } catch { /* onMessage hooks are non-critical */ }
 
       // Conversation tone detection
       if (!internal) {
@@ -1329,6 +1596,9 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         }
       }
     }
+    if (isHeartbeatRun && heartbeatClassification === 'suppress') {
+      changed = pruneSuppressedHeartbeatStreamMessage(current.messages) || changed
+    }
 
     // Fire afterChatTurn hook for all enabled plugins (memory auto-save, logging, etc.)
     try {
@@ -1338,13 +1608,20 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         response: textForPersistence,
         source,
         internal,
-      })
+      }, { enabledIds: pluginsForRun })
     } catch { /* afterChatTurn hooks are non-critical */ }
 
     // Don't extend idle timeout for heartbeat runs — only user-initiated activity counts
-    if (source !== 'heartbeat' && source !== 'heartbeat-wake' && source !== 'main-loop-followup') {
+    if (!isHeartbeatSource(source)) {
       current.lastActiveAt = Date.now()
     }
+
+    refreshSessionIdentityState(current, currentAgent)
+    changed = true
+    try {
+      const archiveSync = syncSessionArchiveMemory(current, { agent: currentAgent })
+      if (archiveSync.stored) changed = true
+    } catch { /* archive sync is best-effort */ }
     fresh[sessionId] = current
     saveSessions(fresh)
     notify(`messages:${sessionId}`)
@@ -1355,7 +1632,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     sessionId,
     text: finalText,
     persisted: shouldPersistAssistant,
-    toolEvents,
+    toolEvents: persistedToolEvents,
     error: errorMessage,
     inputTokens: accumulatedUsage.inputTokens || undefined,
     outputTokens: accumulatedUsage.outputTokens || undefined,