@swarmclawai/swarmclaw 0.7.1 → 0.7.3

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,
@@ -23,12 +24,12 @@ import { buildSessionTools } from './session-tools'
 import type { StructuredToolInterface } from '@langchain/core/tools'
 import type { Session } from '@/types'
 import { stripMainLoopMetaForPersistence } from './main-agent-loop'
+import { getPluginManager } from './plugins'
 import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
-import { getMemoryDb } from './memory-db'
 import { routeTaskIntent } from './capability-router'
 import { notify } from './ws-hub'
 import { resolveConcreteToolPolicyBlock, resolveSessionToolPolicy } from './tool-capability-policy'
-import { toolIdMatches } from './tool-aliases'
+import { pluginIdMatches } from './tool-aliases'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import {
   getCachedLlmResponse,
@@ -38,8 +39,13 @@ 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'
-type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli'
+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 */
 function applyContextClearBoundary(messages: Message[]): Message[] {
@@ -50,6 +56,8 @@ function applyContextClearBoundary(messages: Message[]): Message[] {
 }
 
 interface SessionWithTools {
+  plugins?: string[] | null
+  /** @deprecated Use plugins */
   tools?: string[] | null
 }
 
@@ -90,6 +98,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 {
@@ -99,8 +111,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 || '',
@@ -123,6 +144,96 @@ function collectToolEvent(ev: SSEEvent, bag: MessageToolEvent[]) {
   }
 }
 
+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
+  }
+}
+
+function normalizeWorkspaceSandboxLinks(text: string, cwd: string): string {
+  return text.replace(/sandbox:\/workspace\/([^\s)"'\]`]+)/g, (raw, 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 `/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
+  }
+}
+
 function shouldReplaceRecentAssistantMessage(params: {
   previous: Message | null | undefined
   nextToolEvents: MessageToolEvent[]
@@ -138,12 +249,17 @@ 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',
     'delegate_to_codex_cli',
     'delegate_to_opencode_cli',
+    'delegate_to_gemini_cli',
     'connector_message_tool',
     'sessions_tool',
     'whoami_tool',
@@ -176,15 +292,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> {
@@ -326,7 +451,7 @@ function extractDelegationTask(message: string, toolName: string): string | null
 }
 
 function hasToolEnabled(session: SessionWithTools, toolName: string): boolean {
-  return toolIdMatches(session?.tools || [], toolName)
+  return pluginIdMatches(session?.plugins || session?.tools || [], toolName)
 }
 
 function enabledDelegationTools(session: SessionWithTools): DelegateTool[] {
@@ -334,6 +459,7 @@ function enabledDelegationTools(session: SessionWithTools): DelegateTool[] {
   if (hasToolEnabled(session, 'claude_code') || hasToolEnabled(session, 'delegate')) tools.push('delegate_to_claude_code')
   if (hasToolEnabled(session, 'codex_cli')) tools.push('delegate_to_codex_cli')
   if (hasToolEnabled(session, 'opencode_cli')) tools.push('delegate_to_opencode_cli')
+  if (hasToolEnabled(session, 'gemini_cli')) tools.push('delegate_to_gemini_cli')
   return tools
 }
 
@@ -394,17 +520,28 @@ 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) {
+  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 (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.tools)) {
-    session.tools = Array.isArray(agent.tools) ? [...agent.tools] : []
+  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
@@ -431,6 +568,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 = [
@@ -529,75 +668,6 @@ function estimateConversationTone(text: string): string {
   return 'neutral'
 }
 
-const AUTO_MEMORY_MIN_INTERVAL_MS = 45 * 60 * 1000
-
-function normalizeMemoryText(value: string): string {
-  return (value || '').replace(/\s+/g, ' ').trim()
-}
-
-function shouldStoreAutoMemoryNote(opts: {
-  session: Session
-  source: string
-  internal: boolean
-  message: string
-  response: string
-  now: number
-}): boolean {
-  const { session, source, internal, message, response, now } = opts
-  if (internal) return false
-  if (source !== 'chat' && source !== 'connector') return false
-  if (!session?.agentId) return false
-  if (!Array.isArray(session.tools) || !session.tools.includes('memory')) return false
-  const msg = (message || '').trim()
-  const resp = (response || '').trim()
-  if (msg.length < 20 || resp.length < 40) return false
-  if (/^(ok|okay|cool|thanks|thx|got it|nice)[.! ]*$/i.test(msg)) return false
-  if (resp === 'HEARTBEAT_OK') return false
-  const last = typeof session.lastAutoMemoryAt === 'number' ? session.lastAutoMemoryAt : 0
-  if (last > 0 && now - last < AUTO_MEMORY_MIN_INTERVAL_MS) return false
-  return true
-}
-
-function storeAutoMemoryNote(opts: {
-  session: Session
-  message: string
-  response: string
-  source: string
-  now: number
-}): string | null {
-  const { session, message, response, source, now } = opts
-  try {
-    const db = getMemoryDb()
-    const compactMessage = message.replace(/\s+/g, ' ').trim().slice(0, 220)
-    const compactResponse = response.replace(/\s+/g, ' ').trim().slice(0, 700)
-    const title = `[auto] ${compactMessage.slice(0, 90)}`
-    const content = [
-      `source: ${source}`,
-      `user_request: ${compactMessage}`,
-      `assistant_outcome: ${compactResponse}`,
-    ].join('\n')
-    const latest = db.getLatestBySessionCategory?.(session.id, 'execution')
-    if (latest) {
-      const sameTitle = normalizeMemoryText(latest.title) === normalizeMemoryText(title)
-      const sameContent = normalizeMemoryText(latest.content) === normalizeMemoryText(content)
-      if (sameTitle && sameContent) {
-        session.lastAutoMemoryAt = now
-        return latest.id
-      }
-    }
-    const created = db.add({
-      agentId: session.agentId as string,
-      sessionId: session.id as string,
-      category: 'execution',
-      title,
-      content,
-    })
-    session.lastAutoMemoryAt = now
-    return created?.id || null
-  } catch {
-    return null
-  }
-}
 
 export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promise<ExecuteChatTurnResult> {
   const { message } = input
@@ -618,31 +688,61 @@ 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 toolPolicy = resolveSessionToolPolicy(session.tools, appSettings)
-  const isHeartbeatRun = internal && source === 'heartbeat'
-  const isAutoRunNoHistory = isHeartbeatRun || (internal && source === 'main-loop-followup')
-  const heartbeatStatus = session.mainLoopState?.status || 'idle'
-  const mainLoopIdle = session.name === '__main__'
-    && (heartbeatStatus === 'ok' || heartbeatStatus === 'idle')
-    && !(session.mainLoopState?.pendingEvents?.length > 0)
-  const heartbeatStatusOnly = isHeartbeatRun && mainLoopIdle
-  const toolsForRun = heartbeatStatusOnly ? [] : toolPolicy.enabledTools
-  let sessionForRun = toolsForRun === session.tools
+  const agentForSession = session.agentId ? loadAgents()[session.agentId] : null
+  const toolPolicy = resolveSessionToolPolicy(session.plugins, appSettings)
+  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, tools: toolsForRun }
+    : { ...session, plugins: pluginsForRun }
+  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) {
     sessionForRun = { ...sessionForRun, model: input.modelOverride }
   }
 
-  if (!heartbeatStatusOnly && toolPolicy.blockedTools.length > 0) {
-    const blockedSummary = toolPolicy.blockedTools
+  if (!heartbeatStatusOnly && toolPolicy.blockedPlugins.length > 0) {
+    const blockedSummary = toolPolicy.blockedPlugins
       .map((entry) => `${entry.tool} (${entry.reason})`)
       .join(', ')
-    onEvent?.({ t: 'err', text: `Capability policy blocked tools for this run: ${blockedSummary}` })
+    onEvent?.({ t: 'err', text: `Capability policy blocked plugins for this run: ${blockedSummary}` })
   }
 
   // --- Agent spend-limit enforcement (hourly/daily/monthly) ---
@@ -727,7 +827,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       internal,
       provider: session.provider,
       model: session.model,
-      messagePreview: message.slice(0, 200),
+      messagePreview: effectiveMessage.slice(0, 200),
       hasImage: !!(imagePath || imageUrl),
     },
   })
@@ -744,7 +844,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
 
   if (!internal) {
     const linkAnalysis = await runLinkUnderstanding(message)
-    session.messages.push({
+    const nextUserMessage: Message = {
       role: 'user',
       text: message,
       time: Date.now(),
@@ -752,7 +852,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',
@@ -763,6 +864,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)
@@ -811,19 +915,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}`)
@@ -861,7 +964,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   const responseCacheConfig = resolveLlmResponseCacheConfig(appSettings)
   let responseCacheHit = false
   let responseCacheInput: LlmResponseCacheKeyInput | null = null
-  const hasTools = !!sessionForRun.tools?.length && !NON_LANGGRAPH_PROVIDER_IDS.has(providerType)
+  const hasPlugins = !!(sessionForRun.plugins?.length || sessionForRun.tools?.length) && !NON_LANGGRAPH_PROVIDER_IDS.has(providerType)
 
   let durationMs = 0
   const startTs = Date.now()
@@ -873,11 +976,11 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       ? getSessionMessages(sessionId).slice(-6)
       : undefined
 
-    console.log(`[chat-execution] provider=${providerType}, hasTools=${hasTools}, imagePath=${imagePath || 'none'}, attachedFiles=${attachedFiles?.length || 0}, tools=${(sessionForRun.tools || []).length}`)
-    if (hasTools) {
+    console.log(`[chat-execution] provider=${providerType}, hasPlugins=${hasPlugins}, imagePath=${imagePath || 'none'}, attachedFiles=${attachedFiles?.length || 0}, plugins=${(sessionForRun.plugins || sessionForRun.tools || []).length}`)
+    if (hasPlugins) {
       fullResponse = (await streamAgentChat({
         session: sessionForRun,
-        message: message,
+        message: effectiveMessage,
         imagePath,
         attachedFiles,
         apiKey,
@@ -895,7 +998,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         model: sessionForRun.model,
         apiEndpoint: sessionForRun.apiEndpoint || '',
         systemPrompt,
-        message: message,
+        message: effectiveMessage,
         imagePath,
         imageUrl,
         attachedFiles,
@@ -923,7 +1026,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       } else {
         fullResponse = await provider.handler.streamChat({
           session: sessionForRun,
-          message: message,
+          message: effectiveMessage,
           imagePath,
           apiKey,
           systemPrompt,
@@ -967,7 +1070,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
 
   // Record usage for the direct (non-tools) streamChat path.
   // streamAgentChat already calls appendUsage internally for the tools path.
-  if (!hasTools && fullResponse && !errorMessage && !responseCacheHit) {
+  if (!hasPlugins && fullResponse && !errorMessage && !responseCacheHit) {
     const inputTokens = directUsage.received ? directUsage.inputTokens : Math.ceil(message.length / 4)
     const outputTokens = directUsage.received ? directUsage.outputTokens : Math.ceil(fullResponse.length / 4)
     const totalTokens = inputTokens + outputTokens
@@ -998,7 +1101,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     ? requestedToolNamesFromMessage(message)
     : []
   const routingDecision = (!internal && source === 'chat')
-    ? routeTaskIntent(message, toolsForRun, appSettings)
+    ? routeTaskIntent(message, pluginsForRun, appSettings)
     : null
   const calledNames = new Set((toolEvents || []).map((t) => t.name))
 
@@ -1034,6 +1137,9 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     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') {
@@ -1065,7 +1171,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       return false
     }
     const agent = session.agentId ? loadAgents()[session.agentId] : null
-    const { tools, cleanup } = await buildSessionTools(session.cwd, sessionForRun.tools || [], {
+    const { tools, cleanup } = await buildSessionTools(session.cwd, sessionForRun.plugins || sessionForRun.tools || [], {
       agentId: session.agentId || null,
       sessionId,
       platformAssignScope: agent?.platformAssignScope || 'self',
@@ -1081,10 +1187,16 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       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.`
       }
@@ -1109,10 +1221,11 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     }
   }
 
-  const forcedDelegationTools: Array<'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli'> = [
+  const forcedDelegationTools: DelegateTool[] = [
     'delegate_to_claude_code',
     'delegate_to_codex_cli',
     'delegate_to_opencode_cli',
+    'delegate_to_gemini_cli',
   ]
   for (const toolName of forcedDelegationTools) {
     if (!requestedToolNames.includes(toolName)) continue
@@ -1136,7 +1249,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
     }
   }
@@ -1156,7 +1269,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) {
@@ -1174,7 +1287,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',
     )
   }
@@ -1184,7 +1297,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')
     }
   }
 
@@ -1219,27 +1332,23 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     errorMessage = streamErrors[streamErrors.length - 1]
   }
 
-  const finalText = (fullResponse || '').trim() || (!internal && errorMessage ? `Error: ${errorMessage}` : '')
-  const textForPersistence = stripMainLoopMetaForPersistence(finalText, internal)
+  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
@@ -1275,7 +1384,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) {
@@ -1307,7 +1422,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
@@ -1317,13 +1432,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,
       })) {
@@ -1336,6 +1451,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) {
@@ -1390,30 +1508,32 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         }
       }
     }
+    if (isHeartbeatRun && heartbeatClassification === 'suppress') {
+      changed = pruneSuppressedHeartbeatStreamMessage(current.messages) || changed
+    }
 
-    const autoMemoryEligible = shouldStoreAutoMemoryNote({
-      session: current,
-      source,
-      internal,
-      message: message,
-      response: textForPersistence,
-      now: Date.now(),
-    })
-    if (autoMemoryEligible) {
-      const storedId = storeAutoMemoryNote({
+    // Fire afterChatTurn hook for all enabled plugins (memory auto-save, logging, etc.)
+    try {
+      await getPluginManager().runHook('afterChatTurn', {
         session: current,
-        message: message,
+        message,
         response: textForPersistence,
         source,
-        now: Date.now(),
-      })
-      if (storedId) changed = true
-    }
+        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}`)
@@ -1424,7 +1544,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,