@swarmclawai/swarmclaw 0.8.4 → 0.8.7

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

@@ -1,6 +1,6 @@
 import fs from 'fs'
 import os from 'os'
-import path from 'path'
+import { perf } from './perf'
 import {
   loadSessions,
   saveSessions,
@@ -10,7 +10,6 @@ import {
   loadAgents,
   loadSkills,
   loadSettings,
-  loadUsage,
   appendUsage,
   active,
 } from './storage'
@@ -20,52 +19,102 @@ import { log } from './logger'
 import { logExecution } from './execution-log'
 import { buildToolDisciplineLines, streamAgentChat } from './stream-agent-chat'
 import { runLinkUnderstanding } from './link-understanding'
-import { buildSessionTools } from './session-tools'
-import type { StructuredToolInterface } from '@langchain/core/tools'
 import type { Session } from '@/types'
+import type { ApprovalCategory } from '@/types'
 import { stripMainLoopMetaForPersistence } from './main-agent-loop'
 import { getPluginManager } from './plugins'
 import { isLocalOpenClawEndpoint, 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 { resolveSessionToolPolicy } from './tool-capability-policy'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
+import { buildWorkspaceContext } from './workspace-context'
+import { resolveImagePath } from './resolve-image'
+import {
+  applyContextClearBoundary,
+  shouldApplySessionFreshnessReset,
+  shouldAutoRouteHeartbeatAlerts,
+  shouldPersistInboundUserMessage,
+  translateRequestedToolInvocation,
+  normalizeAssistantArtifactLinks,
+  extractHeartbeatStatus,
+  shouldReplaceRecentAssistantMessage,
+  hasPersistableAssistantPayload,
+  getPersistedAssistantText,
+  getToolEventsSnapshotKey,
+  requestedToolNamesFromMessage,
+  hasDirectLocalCodingTools,
+  parseUsdLimit,
+  getTodaySpendUsd,
+  classifyHeartbeatResponse,
+  estimateConversationTone,
+} from './chat-execution-utils'
+import { runPostLlmToolRouting } from './chat-turn-tool-routing'
 import {
   getCachedLlmResponse,
   resolveLlmResponseCacheConfig,
   setCachedLlmResponse,
   type LlmResponseCacheKeyInput,
 } from './llm-response-cache'
-import { genId } from '@/lib/id'
 import type { Message, MessageToolEvent, SSEEvent, UsageRecord } from '@/types'
-import { markProviderFailure, markProviderSuccess, rankDelegatesByHealth } from './provider-health'
+import { markProviderFailure, markProviderSuccess } 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'
-import { resolveActiveProjectContext } from './project-context'
 import { shouldSuppressHiddenControlText, stripHiddenControlTokens } from './assistant-control'
-import { buildToolEventAssistantSummary } from '@/lib/tool-event-summary'
 import { buildAgentDisabledMessage, isAgentDisabled } from './agent-availability'
-type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli' | 'delegate_to_gemini_cli'
+import { errorMessage as toErrorMessage } from '@/lib/shared-utils'
+
+export {
+  shouldApplySessionFreshnessReset,
+  shouldAutoRouteHeartbeatAlerts,
+  translateRequestedToolInvocation,
+  normalizeAssistantArtifactLinks,
+  requestedToolNamesFromMessage,
+  hasDirectLocalCodingTools,
+}
 
-/** Slice history from the most recent context-clear marker forward */
-function applyContextClearBoundary(messages: Message[]): Message[] {
-  const filterModelHistory = (items: Message[]) => items.filter((message) => message.historyExcluded !== true)
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].kind === 'context-clear') return filterModelHistory(messages.slice(i + 1))
-  }
-  return filterModelHistory(messages)
+export function buildAgentRuntimeCapabilities(enabledPlugins: string[]): string[] {
+  const capabilities = ['heartbeats', 'autonomous_loop', 'multi_agent_chat']
+  if (enabledPlugins.length > 0) capabilities.unshift('tools')
+  return capabilities
 }
 
-interface SessionWithTools {
-  plugins?: string[] | null
-  /** @deprecated Use plugins */
-  tools?: string[] | null
+export function buildNoToolsGuidance(): string[] {
+  return [
+    '## Tool Availability',
+    'No session tools are enabled in this chat.',
+    'Do not imply that a normal read-only action is waiting on user permission or approval when the real blocker is missing tool access.',
+    'If browsing, web fetches, file edits, or other actions are unavailable, state that the capability is not enabled in this session.',
+    'Only mention approval when a real runtime tool explicitly returned an approval requirement for a concrete action.',
+  ]
+}
+
+export function buildEnabledToolsAutonomyGuidance(options?: {
+  approvalsEnabled?: boolean
+  approvalAutoApproveCategories?: ApprovalCategory[] | null
+}): string[] {
+  const lines = [
+    '## Tool Autonomy',
+    'Enabled session tools are already available for normal use in this chat.',
+    'Do not ask the user for permission before using enabled tools for ordinary read-only work, routine diagnostics, or reversible execution steps that are clearly part of the request.',
+    'If the user asks you to use an enabled tool or to perform a task that clearly maps to an enabled tool, attempt that tool path before asking the user to do the work manually.',
+    'Only surface approval or permission as a blocker when a real runtime tool result explicitly requires approval for a concrete state-changing action.',
+  ]
+  if (options?.approvalsEnabled === false) {
+    lines.push('Approvals are disabled platform-wide in this runtime. Do not tell the user that enabled tool use is waiting on approval.')
+  }
+  const autoApproved = Array.isArray(options?.approvalAutoApproveCategories)
+    ? options!.approvalAutoApproveCategories.filter((value): value is ApprovalCategory => typeof value === 'string' && value.trim().length > 0)
+    : []
+  if (autoApproved.length > 0) {
+    lines.push(`These approval categories auto-approve in this runtime: ${autoApproved.join(', ')}.`)
+    lines.push('If a tool-backed action falls into one of those categories, call the tool and let the runtime auto-approve it instead of asking the user first in prose.')
+  }
+  return lines
 }
 
 interface SessionWithCredentials {
@@ -105,15 +154,6 @@ export interface ExecuteChatTurnResult {
   estimatedCost?: number
 }
 
-export function shouldApplySessionFreshnessReset(source: string): boolean {
-  return source !== 'eval'
-}
-
-function shouldPersistInboundUserMessage(internal: boolean, source: string): boolean {
-  if (!internal) return true
-  return source === 'eval'
-}
-
 function extractEventJson(line: string): SSEEvent | null {
   if (!line.startsWith('data: ')) return null
   try {
@@ -156,25 +196,6 @@ export function collectToolEvent(ev: SSEEvent, bag: MessageToolEvent[]) {
   }
 }
 
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-function hasExplicitToolMention(message: string, toolName: string): boolean {
-  const escaped = escapeRegExp(toolName)
-  const negated = new RegExp(`\\b(?:do not|don't|dont|avoid|skip|without|never)\\s+(?:use\\s+|call\\s+|invoke\\s+)?(?:the\\s+)?\`?${escaped}\`?(?:\\s+tool)?\\b`, 'i')
-  if (negated.test(message)) return false
-  const boundary = new RegExp(`(^|[^a-z0-9_])\`?${escaped}\`?([^a-z0-9_]|$)`, 'i')
-  return boundary.test(message)
-}
-
-function hasExplicitGenericToolRequest(message: string, toolName: string): boolean {
-  const escaped = escapeRegExp(toolName)
-  const negated = new RegExp(`\\b(?:do not|don't|dont|avoid|skip|without|never)\\s+(?:use\\s+|call\\s+|invoke\\s+)?(?:the\\s+)?${escaped}(?:\\s+tool)?\\b`, 'i')
-  if (negated.test(message)) return false
-  return new RegExp(`(^|[\\s(])\`${escaped}\`([\\s).,!?]|$)|\\b${escaped}\\s+tool\\b|\\buse\\s+(?:the\\s+)?${escaped}\\b|\\bcall\\s+(?:the\\s+)?${escaped}\\b|\\binvoke\\s+(?:the\\s+)?${escaped}\\b`, 'i').test(message)
-}
-
 export function dedupeConsecutiveToolEvents(events: MessageToolEvent[]): MessageToolEvent[] {
   const sameEvent = (left: MessageToolEvent, right: MessageToolEvent): boolean => (
     left.name === right.name
@@ -231,111 +252,6 @@ export function deriveTerminalRunError(params: {
   return undefined
 }
 
-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',
-  project: 'manage_projects',
-  projects: 'manage_projects',
-  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
@@ -353,156 +269,10 @@ export function isLikelyToolErrorOutput(output: string): boolean {
   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
-  }
-}
-
-function shouldReplaceRecentAssistantMessage(params: {
-  previous: Message | null | undefined
-  nextToolEvents: MessageToolEvent[]
-  nextKind: Message['kind']
-  now: number
-}): boolean {
-  const { previous, nextToolEvents, nextKind, now } = params
-  if (!previous || previous.role !== 'assistant') return false
-  if (nextToolEvents.length === 0) return false
-  if (previous.kind && nextKind && previous.kind !== nextKind) return false
-  if (typeof previous.time === 'number' && now - previous.time > 45_000) return false
-  const prevTools = Array.isArray(previous.toolEvents) ? previous.toolEvents.length : 0
-  return prevTools === 0
-}
-
-function hasPersistableAssistantPayload(text: string, thinking: string, toolEvents: MessageToolEvent[]): boolean {
-  return text.trim().length > 0 || thinking.trim().length > 0 || toolEvents.length > 0
-}
-
-function getPersistedAssistantText(text: string, toolEvents: MessageToolEvent[]): string {
-  const trimmed = text.trim()
-  if (trimmed) return trimmed
-  return buildToolEventAssistantSummary(toolEvents)
-}
-
-function getToolEventsSnapshotKey(toolEvents: MessageToolEvent[]): string {
-  return JSON.stringify(toolEvents.map((event) => [
-    event.name,
-    event.input,
-    event.output || '',
-    event.error === true,
-    event.toolCallId || '',
-  ]))
-}
-
 export function pruneSuppressedHeartbeatStreamMessage(messages: Message[]): boolean {
   return pruneStreamingAssistantArtifacts(messages)
 }
 
-export function requestedToolNamesFromMessage(message: string): string[] {
-  const explicitCandidates = [
-    'delegate_to_claude_code',
-    'delegate_to_codex_cli',
-    'delegate_to_opencode_cli',
-    'delegate_to_gemini_cli',
-    'connector_message_tool',
-    'sessions_tool',
-    'whoami_tool',
-    'search_history_tool',
-    'manage_agents',
-    'manage_tasks',
-    'manage_schedules',
-    'manage_documents',
-    'manage_webhooks',
-    'manage_skills',
-    'manage_connectors',
-    'manage_sessions',
-    'manage_secrets',
-    'manage_capabilities',
-    'manage_platform',
-    'manage_chatrooms',
-    'search_marketplace',
-    'monitor_tool',
-    'plugin_creator_tool',
-    'memory_tool',
-    'memory_search',
-    'memory_get',
-    'memory_store',
-    'memory_update',
-    'wallet_tool',
-    'http_request',
-    'send_file',
-    'sandbox_exec',
-    'sandbox_list_runtimes',
-    'schedule_wake',
-    'spawn_subagent',
-    'ask_human',
-    'context_status',
-    'context_summarize',
-    'openclaw_nodes',
-    'openclaw_workspace',
-  ]
-  const genericCandidates = [
-    'browser',
-    'web',
-    'shell',
-    'files',
-    'edit_file',
-    'git',
-    'canvas',
-    'mailbox',
-    'document',
-    'extract',
-    'table',
-    'crawl',
-    'email',
-  ]
-  const requested = explicitCandidates.filter((name) => hasExplicitToolMention(message, name))
-  for (const name of genericCandidates) {
-    if (hasExplicitGenericToolRequest(message, name)) requested.push(name)
-  }
-  if (hasExplicitGenericToolRequest(message, 'delegate')) {
-    requested.push('delegate')
-  }
-  return Array.from(new Set(requested))
-}
-
 function parseToolJsonObject(raw: string): Record<string, unknown> | null {
   const trimmed = raw.trim()
   if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) return null
@@ -568,216 +338,6 @@ export function reconcileConnectorDeliveryText(text: string, events: MessageTool
   return `I couldn't send that through the configured connector. ${failureSummary}`.trim()
 }
 
-function parseKeyValueArgs(raw: string): Record<string, string> {
-  const out: Record<string, string> = {}
-  const regex = /([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*("([^"]*)"|'([^']*)'|[^\s,]+)/g
-  let match: RegExpExecArray | null = null
-  while ((match = regex.exec(raw)) !== null) {
-    const key = match[1]
-    const value = match[3] ?? match[4] ?? match[2] ?? ''
-    out[key] = value.replace(/^['"]|['"]$/g, '').trim()
-  }
-  return out
-}
-
-function extractConnectorMessageArgs(message: string): {
-  action:
-    | 'list_running'
-    | 'list_targets'
-    | 'start'
-    | 'stop'
-    | 'send'
-    | 'send_voice_note'
-    | 'schedule_followup'
-  platform?: string
-  connectorId?: string
-  to?: string
-  message?: string
-  voiceText?: string
-  voiceId?: string
-  imageUrl?: string
-  fileUrl?: string
-  mediaPath?: string
-  mimeType?: string
-  fileName?: string
-  caption?: string
-  delaySec?: number
-  followUpMessage?: string
-  followUpDelaySec?: number
-  ptt?: boolean
-  approved?: boolean
-} | null {
-  if (!message.toLowerCase().includes('connector_message_tool')) return null
-  const parsed = parseKeyValueArgs(message)
-
-  let payload = parsed.message
-  if (!payload) {
-    const quoted = message.match(/message\s*=\s*("(.*?)"|'(.*?)')/i)
-    if (quoted) payload = (quoted[2] || quoted[3] || '').trim()
-  }
-  if (!payload) {
-    const raw = message.match(/message\s*=\s*([^\n]+)/i)
-    if (raw?.[1]) {
-      payload = raw[1]
-        .replace(/\b(Return|Output|Then|Respond)\b[\s\S]*$/i, '')
-        .trim()
-        .replace(/^['"]|['"]$/g, '')
-    }
-  }
-
-  const actionRaw = (parsed.action || 'send').toLowerCase()
-  const action = (
-    actionRaw === 'list_running'
-    || actionRaw === 'list_targets'
-    || actionRaw === 'start'
-    || actionRaw === 'stop'
-    || actionRaw === 'send'
-    || actionRaw === 'send_voice_note'
-    || actionRaw === 'schedule_followup'
-  )
-    ? actionRaw
-    : 'send'
-  const args: {
-    action:
-      | 'list_running'
-      | 'list_targets'
-      | 'start'
-      | 'stop'
-      | 'send'
-      | 'send_voice_note'
-      | 'schedule_followup'
-    platform?: string
-    connectorId?: string
-    to?: string
-    message?: string
-    voiceText?: string
-    voiceId?: string
-    imageUrl?: string
-    fileUrl?: string
-    mediaPath?: string
-    mimeType?: string
-    fileName?: string
-    caption?: string
-    delaySec?: number
-    followUpMessage?: string
-    followUpDelaySec?: number
-    ptt?: boolean
-    approved?: boolean
-  } = { action }
-  const quoted = (key: string): string | undefined => {
-    const m = message.match(new RegExp(`${key}\\s*=\\s*(\"([^\"]*)\"|'([^']*)')`, 'i'))
-    return (m?.[2] || m?.[3] || '').trim() || undefined
-  }
-  if (parsed.platform) args.platform = parsed.platform
-  if (parsed.connectorId) args.connectorId = parsed.connectorId
-  if (parsed.to) args.to = parsed.to
-  if (payload) args.message = payload
-  if (parsed.voiceText) args.voiceText = parsed.voiceText
-  if (parsed.voiceId) args.voiceId = parsed.voiceId
-  args.imageUrl = parsed.imageUrl || quoted('imageUrl')
-  args.fileUrl = parsed.fileUrl || quoted('fileUrl')
-  args.mediaPath = parsed.mediaPath || quoted('mediaPath')
-  args.mimeType = parsed.mimeType || quoted('mimeType')
-  args.fileName = parsed.fileName || quoted('fileName')
-  args.caption = parsed.caption || quoted('caption')
-  if (parsed.followUpMessage) args.followUpMessage = parsed.followUpMessage
-  if (parsed.delaySec && Number.isFinite(Number(parsed.delaySec))) args.delaySec = Number(parsed.delaySec)
-  if (parsed.followUpDelaySec && Number.isFinite(Number(parsed.followUpDelaySec))) args.followUpDelaySec = Number(parsed.followUpDelaySec)
-  if (parsed.ptt) args.ptt = ['true', '1', 'yes', 'on'].includes(parsed.ptt.toLowerCase())
-  if (parsed.approved) args.approved = ['true', '1', 'yes', 'on'].includes(parsed.approved.toLowerCase())
-  return args
-}
-
-function extractDelegationTask(message: string, toolName: string): string | null {
-  if (!message.toLowerCase().includes(toolName.toLowerCase())) return null
-  const patterns = [
-    /task\s+exactly\s*:\s*"([^"]+)"/i,
-    /task\s+exactly\s*:\s*'([^']+)'/i,
-    /task\s+exactly\s*:\s*([^\n]+?)(?:\.\s|$)/i,
-    /task\s*:\s*"([^"]+)"/i,
-    /task\s*:\s*'([^']+)'/i,
-    /task\s*:\s*([^\n]+?)(?:\.\s|$)/i,
-  ]
-  for (const re of patterns) {
-    const m = message.match(re)
-    const task = (m?.[1] || '').trim()
-    if (task) return task
-  }
-  return null
-}
-
-function hasToolEnabled(session: SessionWithTools, toolName: string): boolean {
-  return pluginIdMatches(session?.plugins || session?.tools || [], toolName)
-}
-
-export function hasDirectLocalCodingTools(session: SessionWithTools): boolean {
-  return [
-    'shell',
-    'execute_command',
-    'files',
-    'edit_file',
-    'openclaw_workspace',
-    'sandbox',
-  ].some((toolName) => hasToolEnabled(session, toolName))
-}
-
-function enabledDelegationTools(session: SessionWithTools): DelegateTool[] {
-  const tools: 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
-}
-
-function parseUsdLimit(value: unknown): number | null {
-  const parsed = typeof value === 'number'
-    ? value
-    : typeof value === 'string'
-      ? Number.parseFloat(value)
-      : Number.NaN
-  if (!Number.isFinite(parsed) || parsed <= 0) return null
-  return Math.max(0.01, Math.min(1_000_000, parsed))
-}
-
-function getTodaySpendUsd(): number {
-  const usage = loadUsage()
-  const dayStart = new Date()
-  dayStart.setHours(0, 0, 0, 0)
-  const minTs = dayStart.getTime()
-  let total = 0
-  for (const records of Object.values(usage)) {
-    for (const record of records || []) {
-      const rec = record as Record<string, unknown>
-      const ts = typeof rec?.timestamp === 'number' ? rec.timestamp : 0
-      if (ts < minTs) continue
-      const cost = typeof rec?.estimatedCost === 'number' ? rec.estimatedCost : 0
-      if (Number.isFinite(cost) && cost > 0) total += cost
-    }
-  }
-  return total
-}
-
-function findFirstUrl(text: string): string | null {
-  const m = text.match(/https?:\/\/[^\s<>"')]+/i)
-  return m?.[0] || null
-}
-
-function isMemoryListIntent(message: string): boolean {
-  const text = message.toLowerCase()
-  if (!/\bmemory|memories|remember\b/.test(text)) return false
-  if (/\b(save|store|memorize|add to memory|write to memory|remember this)\b/.test(text)) return false
-  if (/\bmemory_tool\b/.test(text)) return true
-  return (
-    /\blist\b[\s\w]{0,24}\bmemories\b/.test(text)
-    || /\bshow\b[\s\w]{0,24}\bmemories\b/.test(text)
-    || /\bget\b[\s\w]{0,24}\bmemories\b/.test(text)
-    || /\bwhat\b[\s\w]{0,40}\bmemories\b/.test(text)
-    || /\bwhat do you remember\b/.test(text)
-    || /\brecall\b[\s\w]{0,24}\bmemories?\b/.test(text)
-  )
-}
-
 function syncSessionFromAgent(sessionId: string): void {
   const sessions = loadSessions()
   const session = sessions[sessionId]
@@ -886,6 +446,7 @@ function buildAgentSystemPrompt(session: Session): string | undefined {
 
   const settings = loadSettings()
   const parts: string[] = []
+  const enabledPlugins = Array.isArray(session.plugins) ? session.plugins : (Array.isArray(agent.plugins) ? agent.plugins : [])
 
   // 1. Identity & Persona (Grounded OpenClaw Style)
   const identityLines = [`## My Identity`]
@@ -904,7 +465,9 @@ function buildAgentSystemPrompt(session: Session): string | undefined {
   const runtimeLines = [
     '## Runtime',
     `os=${process.platform} | host=${os.hostname()} | agent=${agent.id} | provider=${agent.provider} | model=${agent.model}`,
-    `capabilities=tools,heartbeats,autonomous_loop,multi_agent_chat`,
+    `capabilities=${buildAgentRuntimeCapabilities(enabledPlugins).join(',')}`,
+    `approvals=${settings.approvalsEnabled === false ? 'disabled' : 'enabled_or_tool_specific'}`,
+    `approval_auto_approve_categories=${Array.isArray(settings.approvalAutoApproveCategories) && settings.approvalAutoApproveCategories.length > 0 ? settings.approvalAutoApproveCategories.join(',') : 'none'}`,
   ]
   parts.push(runtimeLines.join('\n'))
 
@@ -927,7 +490,6 @@ function buildAgentSystemPrompt(session: Session): string | undefined {
 
   // 5b. Workspace context files (HEARTBEAT.md, IDENTITY.md, AGENTS.md, etc.)
   try {
-    const { buildWorkspaceContext } = require('./workspace-context')
     const wsCtx = buildWorkspaceContext({ cwd: session.cwd })
     if (wsCtx.block) parts.push(wsCtx.block)
   } catch {
@@ -943,7 +505,14 @@ function buildAgentSystemPrompt(session: Session): string | undefined {
   ]
   parts.push(thinkingHint.join('\n'))
 
-  const enabledPlugins = Array.isArray(session.plugins) ? session.plugins : (Array.isArray(agent.plugins) ? agent.plugins : [])
+  if (enabledPlugins.length === 0) {
+    parts.push(buildNoToolsGuidance().join('\n'))
+  } else {
+    parts.push(buildEnabledToolsAutonomyGuidance({
+      approvalsEnabled: settings.approvalsEnabled,
+      approvalAutoApproveCategories: settings.approvalAutoApproveCategories,
+    }).join('\n'))
+  }
   const toolDisciplineLines = buildToolDisciplineLines(enabledPlugins)
   if (toolDisciplineLines.length > 0) parts.push(['## Tool Discipline', ...toolDisciplineLines].join('\n'))
   const operatingGuidance = getPluginManager().collectOperatingGuidance(enabledPlugins)
@@ -978,42 +547,6 @@ function resolveApiKeyForSession(session: SessionWithCredentials, provider: Prov
   return null
 }
 
-function stripMarkupForHeartbeat(text: string): string {
-  return text
-    .replace(/<[^>]*>/g, ' ')       // strip HTML tags
-    .replace(/&nbsp;/gi, ' ')       // decode nbsp
-    .replace(/^[*`~_]+/, '')        // strip leading markdown
-    .replace(/[*`~_]+$/, '')        // strip trailing markdown
-    .trim()
-}
-
-const HEARTBEAT_OK_RE = /HEARTBEAT_OK[^\w]{0,4}$/
-const NO_MESSAGE_RE = /NO_MESSAGE[^\w]{0,4}$/
-
-function classifyHeartbeatResponse(text: string, ackMaxChars: number, hadToolCalls: boolean): 'suppress' | 'strip' | 'keep' {
-  const cleaned = stripMarkupForHeartbeat(text)
-  if (cleaned === 'HEARTBEAT_OK' || cleaned === 'NO_MESSAGE') return 'suppress'
-  if (HEARTBEAT_OK_RE.test(cleaned) || NO_MESSAGE_RE.test(cleaned)) return 'suppress'
-  const stripped = cleaned.replace(/HEARTBEAT_OK/gi, '').replace(/NO_MESSAGE/gi, '').trim()
-  if (!stripped) return 'suppress'
-  if (!hadToolCalls && stripped.length <= ackMaxChars) return 'suppress'
-  return stripped.length < cleaned.length ? 'strip' : 'keep'
-}
-
-function estimateConversationTone(text: string): string {
-  const t = text || ''
-  // Technical: code blocks, function signatures, technical terms
-  if (/```/.test(t) || /\b(function|const|let|var|import|export|class|interface|async|await|return)\b/.test(t)) return 'technical'
-  if (/\b(error|bug|debug|stack trace|exception|null|undefined|TypeError)\b/i.test(t)) return 'technical'
-  // Empathetic: emotional/supportive language
-  if (/\b(understand|feel|sorry|empathize|appreciate|grateful|tough|difficult|challenging)\b/i.test(t)) return 'empathetic'
-  // Formal: academic/business language
-  if (/\b(furthermore|regarding|consequently|therefore|henceforth|pursuant|accordingly|notwithstanding)\b/i.test(t)) return 'formal'
-  // Casual: contractions, exclamations, informal language
-  if (/\b(gonna|wanna|gotta|yeah|hey|awesome|cool|lol|btw|tbh)\b/i.test(t) || /!{2,}/.test(t)) return 'casual'
-  return 'neutral'
-}
-
 
 export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promise<ExecuteChatTurnResult> {
   const { message } = input
@@ -1029,6 +562,12 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     signal,
   } = input
 
+  // Resolve image path early: if the filesystem path is gone, fall back to
+  // the upload URL which resolveImagePath maps back to the uploads directory.
+  const resolvedImagePath = resolveImagePath(imagePath, imageUrl) ?? undefined
+
+  const endTurnPerf = perf.start('chat-execution', 'executeSessionChatTurn', { sessionId, source })
+
   syncSessionFromAgent(sessionId)
 
   const sessions = loadSessions()
@@ -1266,9 +805,19 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   let lastPartialSaveAt = 0
   let lastPartialSnapshotKey = ''
   let partialSaveTimeout: ReturnType<typeof setTimeout> | null = null
+  let partialPersistenceClosed = false
+
+  const stopPartialAssistantPersistence = () => {
+    partialPersistenceClosed = true
+    if (partialSaveTimeout) {
+      clearTimeout(partialSaveTimeout)
+      partialSaveTimeout = null
+    }
+  }
 
   const persistStreamingAssistantArtifact = () => {
     partialSaveTimeout = null
+    if (partialPersistenceClosed) return
     const persistedToolEvents = toolEvents.length ? dedupeConsecutiveToolEvents([...toolEvents]) : []
     if (!hasPersistableAssistantPayload(streamingPartialText, thinkingText, persistedToolEvents)) return
 
@@ -1306,6 +855,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   }
 
   const queuePartialAssistantPersist = (immediate = false) => {
+    if (partialPersistenceClosed) return
     const now = Date.now()
     const minIntervalMs = 400
     if (immediate || now - lastPartialSaveAt >= minIntervalMs) {
@@ -1398,12 +948,21 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   let responseCacheHit = false
   let responseCacheInput: LlmResponseCacheKeyInput | null = null
   const useLocalOpenClawNativeRuntime = providerType === 'openclaw' && isLocalOpenClawEndpoint(sessionForRun.apiEndpoint)
-  const hasPlugins = !!(sessionForRun.plugins?.length || sessionForRun.tools?.length)
+  const enabledSessionPlugins = Array.isArray(sessionForRun.plugins)
+    ? sessionForRun.plugins
+    : (Array.isArray(sessionForRun.tools) ? sessionForRun.tools : [])
+  const hasPlugins = enabledSessionPlugins.length > 0
     && !NON_LANGGRAPH_PROVIDER_IDS.has(providerType)
     && !useLocalOpenClawNativeRuntime
 
   let durationMs = 0
   const startTs = Date.now()
+  const endLlmPerf = perf.start('chat-execution', 'llm-round-trip', {
+    sessionId,
+    provider: providerType,
+    hasPlugins,
+    pluginCount: enabledSessionPlugins.length,
+  })
   try {
     // Heartbeat runs get a small tail of recent messages so the agent can see
     // prior findings and avoid repeating the same searches. Full history is
@@ -1412,12 +971,12 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       ? getSessionMessages(sessionId).slice(-6)
       : undefined
 
-    console.log(`[chat-execution] provider=${providerType}, hasPlugins=${hasPlugins}, localOpenClawNative=${useLocalOpenClawNativeRuntime}, imagePath=${imagePath || 'none'}, attachedFiles=${attachedFiles?.length || 0}, plugins=${(sessionForRun.plugins || sessionForRun.tools || []).length}`)
+    console.log(`[chat-execution] provider=${providerType}, hasPlugins=${hasPlugins}, localOpenClawNative=${useLocalOpenClawNativeRuntime}, imagePath=${resolvedImagePath || 'none'}, attachedFiles=${attachedFiles?.length || 0}, plugins=${enabledSessionPlugins.length}`)
     if (hasPlugins) {
       const result = await streamAgentChat({
         session: sessionForRun,
         message: effectiveMessage,
-        imagePath,
+        imagePath: resolvedImagePath,
         attachedFiles,
         apiKey,
         systemPrompt,
@@ -1464,7 +1023,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         fullResponse = await provider.handler.streamChat({
           session: sessionForRun,
           message: effectiveMessage,
-          imagePath,
+          imagePath: resolvedImagePath,
           apiKey,
           systemPrompt,
           write: (raw: string) => parseAndEmit(raw),
@@ -1484,8 +1043,10 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       }
     }
     durationMs = Date.now() - startTs
+    endLlmPerf({ durationMs, cacheHit: responseCacheHit })
   } catch (err: unknown) {
-    errorMessage = err instanceof Error ? err.message : String(err)
+    endLlmPerf({ error: true })
+    errorMessage = toErrorMessage(err)
     const failureText = errorMessage || 'Run failed.'
     markProviderFailure(providerType, failureText)
     emit({ t: 'err', text: failureText })
@@ -1497,7 +1058,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     })
   } finally {
     clearInterval(partialSaveTimer)
-    if (partialSaveTimeout) clearTimeout(partialSaveTimeout)
+    stopPartialAssistantPersistence()
     active.delete(sessionId)
     if (signal) signal.removeEventListener('abort', abortFromOutside)
   }
@@ -1535,197 +1096,32 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     }
   }
 
-  const requestedToolNames = (!internal && source === 'chat')
-    ? requestedToolNamesFromMessage(message)
-    : []
-  const routingDecision = (!internal && source === 'chat')
-    ? routeTaskIntent(message, pluginsForRun, appSettings)
-    : null
-  const calledNames = new Set((toolEvents || []).map((t) => t.name))
-
-  const invokeSessionTool = async (toolName: string, args: Record<string, unknown>, failurePrefix: string): Promise<boolean> => {
-    const blockedReason = resolveConcreteToolPolicyBlock(toolName, toolPolicy, appSettings)
-    if (blockedReason) {
-      emit({ t: 'err', text: `Capability policy blocked tool invocation "${toolName}": ${blockedReason}` })
-      return false
-    }
-    if (
-      appSettings.safetyRequireApprovalForOutbound === true
-      && toolName === 'connector_message_tool'
-      && source !== 'chat'
-    ) {
-      emit({ t: 'err', text: 'Outbound connector messaging requires explicit user approval.' })
-      return false
-    }
-    const agent = session.agentId ? loadAgents()[session.agentId] : null
-    const activeProjectContext = resolveActiveProjectContext(session)
-    const { tools, cleanup } = await buildSessionTools(session.cwd, sessionForRun.plugins || sessionForRun.tools || [], {
-      agentId: session.agentId || null,
-      sessionId,
-      platformAssignScope: agent?.platformAssignScope || 'self',
-      mcpServerIds: agent?.mcpServerIds,
-      mcpDisabledTools: agent?.mcpDisabledTools,
-      projectId: activeProjectContext.projectId,
-      projectRoot: activeProjectContext.projectRoot,
-      projectName: activeProjectContext.project?.name || null,
-      projectDescription: activeProjectContext.project?.description || null,
-      memoryScopeMode: (((session as unknown as Record<string, unknown>).memoryScopeMode as string | null | undefined) ?? agent?.memoryScopeMode ?? null),
-    })
-    try {
-      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)
-      const toolCallId = genId()
-      emit({ t: 'tool_call', toolName, toolInput, toolCallId })
-      const toolOutput = await selectedTool.invoke(translated.args)
-      const outputText = typeof toolOutput === 'string' ? toolOutput : JSON.stringify(toolOutput)
-      emit({ t: 'tool_result', toolName, toolOutput: outputText, toolCallId })
-      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.`
-      }
-      calledNames.add(toolName)
-      return true
-    } catch (forceErr: unknown) {
-      emit({ t: 'err', text: `${failurePrefix}: ${forceErr instanceof Error ? forceErr.message : String(forceErr)}` })
-      return false
-    } finally {
-      await cleanup()
-    }
-  }
-
-  if (requestedToolNames.includes('connector_message_tool') && !calledNames.has('connector_message_tool')) {
-    const forcedArgs = extractConnectorMessageArgs(message)
-    if (forcedArgs) {
-      await invokeSessionTool(
-        'connector_message_tool',
-        forcedArgs as unknown as Record<string, unknown>,
-        'Forced connector_message_tool invocation failed',
-      )
-    }
-  }
-
-  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
-    if (calledNames.has(toolName)) continue
-    const task = extractDelegationTask(message, toolName)
-    if (!task) continue
-    await invokeSessionTool(toolName, { task }, `Forced ${toolName} invocation failed`)
-  }
-
-  const hasDelegationCall = forcedDelegationTools.some((toolName) => calledNames.has(toolName))
-  const enabledDelegateTools = enabledDelegationTools(sessionForRun)
-  const shouldAutoDelegateCoding = (!internal && source === 'chat')
-    && enabledDelegateTools.length > 0
-    && !hasDelegationCall
-    && calledNames.size === 0
-    && !requestedToolNames.length
-    && !hasDirectLocalCodingTools(sessionForRun)
-    && routingDecision?.intent === 'coding'
-
-  if (shouldAutoDelegateCoding) {
-    const baseDelegationOrder = routingDecision?.preferredDelegates?.length
-      ? routingDecision.preferredDelegates
-      : forcedDelegationTools
-    const delegationOrder = rankDelegatesByHealth(baseDelegationOrder as DelegateTool[])
-      .filter((tool) => enabledDelegateTools.includes(tool))
-    for (const delegateTool of delegationOrder) {
-      const invoked = await invokeSessionTool(delegateTool, { task: effectiveMessage.trim() }, 'Auto-delegation failed')
-      if (invoked) break
-    }
-  }
-
-  const shouldFailoverDelegate = (!internal && source === 'chat')
-    && !!errorMessage
-    && !(fullResponse || '').trim()
-    && enabledDelegateTools.length > 0
-    && !hasDelegationCall
-    && (routingDecision?.intent === 'coding' || routingDecision?.intent === 'general')
-  if (shouldFailoverDelegate) {
-    const preferred = routingDecision?.preferredDelegates?.length
-      ? routingDecision.preferredDelegates
-      : forcedDelegationTools
-    const fallbackOrder = rankDelegatesByHealth(preferred as DelegateTool[])
-      .filter((tool) => enabledDelegateTools.includes(tool))
-    for (const delegateTool of fallbackOrder) {
-      const invoked = await invokeSessionTool(
-        delegateTool,
-        { task: effectiveMessage.trim() },
-        `Provider failover via ${delegateTool} failed`,
-      )
-      if (invoked) {
-        errorMessage = undefined
-        break
-      }
-    }
-  }
-
-  const canAutoRouteWithTools = (!internal && source === 'chat')
-    && !!routingDecision
-    && calledNames.size === 0
-    && requestedToolNames.length === 0
-
-  if (canAutoRouteWithTools && routingDecision?.intent === 'browsing' && routingDecision.primaryUrl && hasToolEnabled(sessionForRun, 'browser')) {
-    await invokeSessionTool(
-      'browser',
-      { action: 'read_page', url: routingDecision.primaryUrl },
-      'Auto browser routing failed',
-    )
-  }
-
-  if (canAutoRouteWithTools && routingDecision?.intent === 'research') {
-    const routeUrl = routingDecision.primaryUrl || findFirstUrl(message)
-    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: effectiveMessage.trim(), maxResults: 5 }, 'Auto web_search routing failed')
-    }
-  }
-
-  if (
-    canAutoRouteWithTools
-    && calledNames.size === 0
-    && hasToolEnabled(sessionForRun, 'memory')
-    && isMemoryListIntent(message)
-  ) {
-    await invokeSessionTool(
-      'memory_tool',
-      { action: 'list', key: '', scope: 'auto' },
-      'Auto memory listing failed',
-    )
-  }
-
-  if (requestedToolNames.length > 0) {
-    const missed = requestedToolNames.filter((name) => !calledNames.has(name))
-    if (missed.length > 0) {
-      const notice = `Tool execution notice: requested tool(s) ${missed.join(', ')} were not actually invoked in this run.`
-      emit({ t: 'err', text: notice })
-      if (!fullResponse.includes('Tool execution notice:')) {
-        const trimmedResponse = (fullResponse || '').trim()
-        fullResponse = trimmedResponse
-          ? `${trimmedResponse}\n\n${notice}`
-          : notice
-      }
+  const endPostProcessPerf = perf.start('chat-execution', 'post-process', { sessionId })
+  const toolRoutingResult = await runPostLlmToolRouting({
+    session: sessionForRun,
+    sessionId,
+    message,
+    effectiveMessage,
+    enabledPlugins: pluginsForRun,
+    toolPolicy,
+    appSettings,
+    internal,
+    source,
+    toolEvents,
+    emit,
+  }, fullResponse, errorMessage)
+
+  fullResponse = toolRoutingResult.fullResponse
+  errorMessage = toolRoutingResult.errorMessage
+
+  if (toolRoutingResult.missedRequestedTools.length > 0) {
+    const notice = `Tool execution notice: requested tool(s) ${toolRoutingResult.missedRequestedTools.join(', ')} were not actually invoked in this run.`
+    emit({ t: 'err', text: notice })
+    if (!fullResponse.includes('Tool execution notice:')) {
+      const trimmedResponse = (fullResponse || '').trim()
+      fullResponse = trimmedResponse
+        ? `${trimmedResponse}\n\n${notice}`
+        : notice
     }
   }
 
@@ -1955,6 +1351,15 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     notify(`messages:${sessionId}`)
   }
 
+  endPostProcessPerf({ toolEventCount: persistedToolEvents.length })
+  endTurnPerf({
+    durationMs,
+    toolEventCount: persistedToolEvents.length,
+    inputTokens: accumulatedUsage.inputTokens || 0,
+    outputTokens: accumulatedUsage.outputTokens || 0,
+    error: !!errorMessage,
+  })
+
   return {
     runId,
     sessionId,