savant-code 0.0.16 → 0.0.19

package/agents/context-pruner.ts

@@ -0,0 +1,1076 @@
+import { publisher } from './constants'
+
+import type { AgentDefinition, ToolCall } from './types/agent-definition'
+import type {
+  FilePart,
+  ImagePart,
+  JSONValue,
+  Message,
+  TextPart,
+  ToolMessage,
+  UserMessage,
+} from './types/util-types'
+
+const definition: AgentDefinition = {
+  id: 'context-pruner',
+  publisher,
+  displayName: 'Context Pruner',
+  model: 'anthropic/claude-sonnet-4.6',
+
+  spawnerPrompt: `Spawn this agent between steps to prune context, summarizing the conversation into a condensed format when context exceeds the limit.`,
+
+  inputSchema: {
+    params: {
+      type: 'object',
+      properties: {
+        maxContextLength: {
+          type: 'number',
+        },
+        assistantToolBudget: {
+          type: 'number',
+        },
+        userBudget: {
+          type: 'number',
+        },
+        cacheExpiryMs: {
+          type: 'number',
+        },
+      },
+      required: [],
+    },
+  },
+
+  inheritParentSystemPrompt: true,
+  includeMessageHistory: true,
+
+  handleSteps: function* ({ agentState, params, logger }) {
+    // =============================================================================
+    // Constants (must be inside handleSteps since it's serialized to a string)
+    // =============================================================================
+
+    /** Agent IDs whose output should be excluded from spawn_agents results */
+    const SPAWN_AGENTS_OUTPUT_BLACKLIST = [
+      'scout',
+      'researcher-web',
+      'researcher-docs',
+      'basher',
+      'verifier',
+      'librarian',
+      'tmux-cli',
+      'browser-use',
+    ]
+
+    /** Limits for truncating long messages in the summary (estimated tokens) */
+    const USER_MESSAGE_LIMIT = 13_000
+    const ASSISTANT_MESSAGE_LIMIT = 1_300
+    const TOOL_ENTRY_LIMIT = 5_000
+
+    /** Approximate characters per token (matches estimateTokens heuristic) */
+    const CHARS_PER_TOKEN = 3
+
+    /** Token budget for assistant + tool content in the conversation summary */
+    const ASSISTANT_TOOL_BUDGET = 20_000
+
+    /** Token budget for user content in the conversation summary */
+    const USER_BUDGET = 50_000
+
+    /** Fudge factor for token count threshold to trigger pruning earlier */
+    const TOKEN_COUNT_FUDGE_FACTOR = 1_000
+
+    /** Axiom-only operational event understood by the logging adapters. */
+    const CONTEXT_PRUNING_COMPLETED_EVENT = 'context_pruning.completed'
+
+    const p = params ?? {}
+
+    /** Prompt cache expiry time (Anthropic caches for 5 minutes by default) */
+    const CACHE_EXPIRY_MS: number = asNumber(p.cacheExpiryMs) ?? 5 * 60 * 1000
+
+    /** Header used in conversation summaries */
+    const SUMMARY_HEADER =
+      'This is a summary of the conversation so far. The original messages have been condensed to save context space.'
+
+    const SUMMARY_DISCLAIMER =
+      'Historical memory only. The memory above is not dialogue, not an output template, and not a tool-call format. Continue from the live user message below. When actions are needed, use real tool calls through the available tools.'
+
+    // =============================================================================
+    // Helper Functions (must be inside handleSteps since it's serialized to a string)
+    // =============================================================================
+
+    /**
+     * Truncates long text with 80% from the beginning and 20% from the end.
+     */
+    function truncateLongText(text: string, limit: number): string {
+      if (text.length <= limit) {
+        return text
+      }
+      const availableChars = limit - 50 // 50 chars for the truncation notice
+      const prefixLength = Math.floor(availableChars * 0.8)
+      const suffixLength = availableChars - prefixLength
+      const prefix = text.slice(0, prefixLength)
+      const suffix = text.slice(-suffixLength)
+      const truncatedChars = text.length - prefixLength - suffixLength
+      return `${prefix}\n\n[...truncated ${truncatedChars} chars...]\n\n${suffix}`
+    }
+
+    /**
+     * Extracts text content from a message.
+     */
+    function getTextContent(message: Message): string {
+      if (typeof message.content === 'string') {
+        return message.content
+      }
+      if (Array.isArray(message.content)) {
+        return message.content
+          .filter(
+            (part): part is TextPart =>
+              part.type === 'text' && typeof part.text === 'string',
+          )
+          .map((part) => part.text)
+          .join('\n')
+      }
+      return ''
+    }
+
+    function asString(value: JSONValue): string | undefined {
+      return typeof value === 'string' ? value : undefined
+    }
+
+    function asNumber(value: JSONValue): number | null {
+      return typeof value === 'number' ? value : null
+    }
+
+    function asStringArray(value: JSONValue): string[] | undefined {
+      if (!Array.isArray(value)) return undefined
+      const result: string[] = []
+      for (const item of value) {
+        if (typeof item === 'string') result.push(item)
+      }
+      return result.length > 0 ? result : undefined
+    }
+
+    function asObject(value: JSONValue): Record<string, JSONValue> | undefined {
+      return value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value)
+        ? value
+        : undefined
+    }
+
+    function asAgentSpawnArray(value: JSONValue):
+      | Array<{
+          agent_type: string
+          prompt?: string
+          params?: Record<string, JSONValue>
+        }>
+      | undefined {
+      if (!Array.isArray(value)) return undefined
+      const result: Array<{
+        agent_type: string
+        prompt?: string
+        params?: Record<string, JSONValue>
+      }> = []
+      for (const item of value) {
+        const obj = asObject(item)
+        if (!obj) continue
+        const agent_type = asString(obj.agent_type)
+        if (!agent_type) continue
+        const prompt = asString(obj.prompt)
+        const params = asObject(obj.params)
+        result.push({
+          agent_type,
+          ...(prompt && { prompt }),
+          ...(params && { params }),
+        })
+      }
+      return result.length > 0 ? result : undefined
+    }
+
+    function asTodoList(
+      value: JSONValue,
+    ): Array<{ task: string; completed: boolean }> | undefined {
+      if (!Array.isArray(value)) return undefined
+      const result: Array<{ task: string; completed: boolean }> = []
+      for (const item of value) {
+        const obj = asObject(item)
+        if (!obj) continue
+        const task = asString(obj.task)
+        if (task === undefined) continue
+        result.push({ task, completed: obj.completed === true })
+      }
+      return result.length > 0 ? result : undefined
+    }
+
+    function asQuestionList(
+      value: JSONValue,
+    ): Array<{ question: string }> | undefined {
+      if (!Array.isArray(value)) return undefined
+      const result: Array<{ question: string }> = []
+      for (const item of value) {
+        const obj = asObject(item)
+        if (!obj) continue
+        const question = asString(obj.question)
+        if (question === undefined) continue
+        result.push({ question })
+      }
+      return result.length > 0 ? result : undefined
+    }
+
+    function asAnswerList(value: JSONValue):
+      | Array<{
+          selectedOption?: string
+          selectedOptions?: string[]
+          otherText?: string
+        }>
+      | undefined {
+      if (!Array.isArray(value)) return undefined
+      const result: Array<{
+        selectedOption?: string
+        selectedOptions?: string[]
+        otherText?: string
+      }> = []
+      for (const item of value) {
+        const obj = asObject(item)
+        if (!obj) continue
+        const selectedOption = asString(obj.selectedOption)
+        const selectedOptions = asStringArray(obj.selectedOptions)
+        const otherText = asString(obj.otherText)
+        result.push({
+          ...(selectedOption && { selectedOption }),
+          ...(selectedOptions && { selectedOptions }),
+          ...(otherText && { otherText }),
+        })
+      }
+      return result.length > 0 ? result : undefined
+    }
+
+    function asAgentResultList(value: JSONValue):
+      | Array<{
+          agentName?: string
+          agentType?: string
+          value?: { type?: string; value?: JSONValue }
+        }>
+      | undefined {
+      if (!Array.isArray(value)) return undefined
+      const result: Array<{
+        agentName?: string
+        agentType?: string
+        value?: { type?: string; value?: JSONValue }
+      }> = []
+      for (const item of value) {
+        const obj = asObject(item)
+        if (!obj) continue
+        const agentName = asString(obj.agentName)
+        const agentType = asString(obj.agentType)
+        const valueObj = asObject(obj.value)
+        let inner: { type?: string; value?: JSONValue } | undefined
+        if (valueObj) {
+          const type = asString(valueObj.type)
+          const v = valueObj.value
+          inner = {
+            ...(type && { type }),
+            ...(v !== undefined && { value: v }),
+          }
+        }
+        const entry: {
+          agentName?: string
+          agentType?: string
+          value?: { type?: string; value?: JSONValue }
+        } = {}
+        if (agentName) entry.agentName = agentName
+        if (agentType) entry.agentType = agentType
+        if (inner) entry.value = inner
+        result.push(entry)
+      }
+      return result
+    }
+
+    /**
+     * Summarizes a tool call into a human-readable description.
+     */
+    function summarizeToolCall(
+      toolName: string,
+      input: Record<string, JSONValue>,
+    ): string {
+      switch (toolName) {
+        case 'read_files': {
+          const paths = asStringArray(input.paths)
+          if (paths && paths.length > 0) {
+            return `inspected files: ${paths.join(', ')}`
+          }
+          return 'inspected files'
+        }
+        case 'write_file': {
+          const path = asString(input.path)
+          return path ? `wrote file: ${path}` : 'wrote a file'
+        }
+        case 'str_replace': {
+          const path = asString(input.path)
+          return path ? `edited file: ${path}` : 'edited a file'
+        }
+        case 'propose_write_file': {
+          const path = asString(input.path)
+          return path ? `proposed writing: ${path}` : 'proposed a file write'
+        }
+        case 'propose_str_replace': {
+          const path = asString(input.path)
+          return path ? `proposed editing: ${path}` : 'proposed a file edit'
+        }
+        case 'read_subtree': {
+          const paths = asStringArray(input.paths)
+          if (paths && paths.length > 0) {
+            return `inspected subtrees: ${paths.join(', ')}`
+          }
+          return 'inspected a subtree'
+        }
+        case 'code_search': {
+          const pattern = asString(input.pattern)
+          const flags = asString(input.flags)
+          if (pattern && flags) {
+            return `code search for "${pattern}" (${flags})`
+          }
+          return pattern ? `code search for "${pattern}"` : 'code search'
+        }
+        case 'glob': {
+          const pattern = asString(input.pattern)
+          return pattern ? `glob search for ${pattern}` : 'glob search'
+        }
+        case 'list_directory': {
+          const path = asString(input.path)
+          return path ? `listed directory: ${path}` : 'listed a directory'
+        }
+        case 'find_files': {
+          const prompt = asString(input.prompt)
+          return prompt
+            ? `file-finding request: "${prompt}"`
+            : 'file-finding request'
+        }
+        case 'run_terminal_command': {
+          const command = asString(input.command)
+          if (command) {
+            const shortCmd =
+              command.length > 50 ? command.slice(0, 50) + '...' : command
+            return `ran command: ${shortCmd}`
+          }
+          return 'ran a terminal command'
+        }
+        case 'spawn_agents':
+        case 'spawn_agent_inline': {
+          const agents = asAgentSpawnArray(input.agents)
+          const agentType = asString(input.agent_type)
+          const prompt = asString(input.prompt)
+          const agentParams = asObject(input.params)
+
+          if (agents && agents.length > 0) {
+            const agentDetails = agents.map((a) => {
+              let detail = a.agent_type
+              const extras: string[] = []
+              if (a.prompt) {
+                const truncatedPrompt =
+                  a.prompt.length > 1000
+                    ? a.prompt.slice(0, 1000) + '...'
+                    : a.prompt
+                extras.push(`prompt: "${truncatedPrompt}"`)
+              }
+              if (a.params && Object.keys(a.params).length > 0) {
+                const paramsStr = JSON.stringify(a.params)
+                const truncatedParams =
+                  paramsStr.length > 1000
+                    ? paramsStr.slice(0, 1000) + '...'
+                    : paramsStr
+                extras.push(`params: ${truncatedParams}`)
+              }
+              if (extras.length > 0) {
+                detail += ` (${extras.join(', ')})`
+              }
+              return detail
+            })
+            return `delegated agents:\n${agentDetails.map((d) => `- ${d}`).join('\n')}`
+          }
+          if (agentType) {
+            const extras: string[] = []
+            if (prompt) {
+              const truncatedPrompt =
+                prompt.length > 1000 ? prompt.slice(0, 1000) + '...' : prompt
+              extras.push(`prompt: "${truncatedPrompt}"`)
+            }
+            if (agentParams && Object.keys(agentParams).length > 0) {
+              const paramsStr = JSON.stringify(agentParams)
+              const truncatedParams =
+                paramsStr.length > 1000
+                  ? paramsStr.slice(0, 1000) + '...'
+                  : paramsStr
+              extras.push(`params: ${truncatedParams}`)
+            }
+            if (extras.length > 0) {
+              return `delegated agent ${agentType} (${extras.join(', ')})`
+            }
+            return `delegated agent ${agentType}`
+          }
+          return 'delegated agent work'
+        }
+        case 'write_todos': {
+          const todos = asTodoList(input.todos)
+          if (todos) {
+            const completed = todos.filter((t) => t.completed).length
+            const incomplete = todos.filter((t) => !t.completed)
+            if (incomplete.length === 0) {
+              return `Todos: ${completed}/${todos.length} complete (all done!)`
+            }
+            const remainingTasks = incomplete
+              .map((t) => `- ${t.task}`)
+              .join('\n')
+            return `Todos: ${completed}/${todos.length} complete. Remaining:\n${remainingTasks}`
+          }
+          return 'Updated todos'
+        }
+        case 'ask_user': {
+          const questions = asQuestionList(input.questions)
+          if (questions && questions.length > 0) {
+            const questionTexts = questions.map((q) => q.question).join('; ')
+            const truncated =
+              questionTexts.length > 200
+                ? questionTexts.slice(0, 200) + '...'
+                : questionTexts
+            return `Asked user: ${truncated}`
+          }
+          return 'Asked user question'
+        }
+        case 'suggest_followups':
+          return 'Suggested followups'
+        case 'web_search': {
+          const query = asString(input.query)
+          return query ? `web search for "${query}"` : 'web search'
+        }
+        case 'read_url': {
+          const url = asString(input.url)
+          return url ? `read URL: ${url}` : 'read a URL'
+        }
+        case 'gravity_index': {
+          const query = asString(input.query)
+          const action = asString(input.action)
+          if (query) {
+            return `Gravity Index ${action ?? 'search'} for "${query}"`
+          }
+          return action ? `Gravity Index ${action}` : 'Gravity Index use'
+        }
+        case 'read_docs': {
+          const libraryTitle = asString(input.libraryTitle)
+          const topic = asString(input.topic)
+          if (libraryTitle && topic) {
+            return `consulted docs: ${libraryTitle} - ${topic}`
+          }
+          return libraryTitle
+            ? `consulted docs: ${libraryTitle}`
+            : 'consulted docs'
+        }
+        case 'set_output':
+          return 'set structured output'
+        case 'set_messages':
+          return 'updated message history'
+        default:
+          return `used tool ${toolName}`
+      }
+    }
+
+    // =============================================================================
+    // Main Logic
+    // =============================================================================
+
+    const messages = agentState.messageHistory
+    const maxContextLength: number = asNumber(p.maxContextLength) ?? 200_000
+
+    // STEP 0: Always remove the last INSTRUCTIONS_PROMPT and SUBAGENT_SPAWN
+    // (these are inserted for the context-pruner subagent itself)
+    let currentMessages = [...messages]
+    const lastInstructionsPromptIndex = currentMessages.findLastIndex(
+      (message) => message.tags?.includes('INSTRUCTIONS_PROMPT'),
+    )
+    if (lastInstructionsPromptIndex !== -1) {
+      currentMessages.splice(lastInstructionsPromptIndex, 1)
+    }
+    const lastSubagentSpawnIndex = currentMessages.findLastIndex((message) =>
+      message.tags?.includes('SUBAGENT_SPAWN'),
+    )
+    if (lastSubagentSpawnIndex !== -1) {
+      currentMessages.splice(lastSubagentSpawnIndex, 1)
+    }
+
+    // Also remove the params USER_PROMPT if params were provided to this agent
+    // (this is the message like <user_message>{"cacheExpiryMs": 600000}</user_message>)
+    if (params && Object.keys(params).length > 0) {
+      const lastUserPromptIndex = currentMessages.findLastIndex((message) =>
+        message.tags?.includes('USER_PROMPT'),
+      )
+      if (lastUserPromptIndex !== -1) {
+        currentMessages.splice(lastUserPromptIndex, 1)
+      }
+    }
+
+    // Check for prompt cache miss (>5 min gap before the USER_PROMPT message)
+    // The USER_PROMPT is the actual user message; INSTRUCTIONS_PROMPT comes after it
+    // We need to find the USER_PROMPT and check the gap between it and the last assistant message
+    let cacheWillMiss = false
+    let cacheGapMs: number | null = null
+    const userPromptIndex = currentMessages.findLastIndex((message) =>
+      message.tags?.includes('USER_PROMPT'),
+    )
+    if (userPromptIndex > 0) {
+      const userPromptMsg = currentMessages[userPromptIndex]
+      // Find the last assistant message before USER_PROMPT (tool messages don't have sentAt)
+      let lastAssistantMsg: Message | undefined
+      for (let i = userPromptIndex - 1; i >= 0; i--) {
+        if (currentMessages[i].role === 'assistant') {
+          lastAssistantMsg = currentMessages[i]
+          break
+        }
+      }
+      if (
+        userPromptMsg !== undefined &&
+        typeof userPromptMsg.sentAt === 'number' &&
+        lastAssistantMsg !== undefined &&
+        typeof lastAssistantMsg.sentAt === 'number'
+      ) {
+        const gap = userPromptMsg.sentAt - lastAssistantMsg.sentAt
+        cacheGapMs = gap
+        cacheWillMiss = gap > CACHE_EXPIRY_MS
+      }
+    }
+
+    const contextLimitExceeded =
+      agentState.contextTokenCount + TOKEN_COUNT_FUDGE_FACTOR > maxContextLength
+
+    // Check if we need to prune at all:
+    // - Prune when context exceeds max, OR
+    // - Prune when prompt cache will miss (>5 min gap) to take advantage of fresh context
+    // If not, return messages with just the subagent-specific tags removed
+    if (!contextLimitExceeded && !cacheWillMiss) {
+      yield {
+        toolName: 'set_messages',
+        input: { messages: currentMessages },
+        includeToolCall: false,
+      }
+      return
+    }
+
+    // === SUMMARIZATION MODE ===
+    // Find and extract the last remaining INSTRUCTIONS_PROMPT message (for the parent agent)
+    // to be preserved as the second message after the summary
+    let instructionsPromptMessage: Message | null = null
+    const lastRemainingInstructionsIndex = currentMessages.findLastIndex(
+      (message) => message.tags?.includes('INSTRUCTIONS_PROMPT'),
+    )
+    if (lastRemainingInstructionsIndex !== -1) {
+      instructionsPromptMessage =
+        currentMessages[lastRemainingInstructionsIndex]
+      currentMessages.splice(lastRemainingInstructionsIndex, 1)
+    }
+
+    // === SUMMARIZATION STRATEGY ===
+    // 1. Summarize ALL messages (apply transformations: truncation, tool summaries, etc.)
+    // 2. Walk backwards through summarized parts to apply token budgets
+    // 3. Older summarized parts beyond the budgets are dropped
+
+    const assistantToolBudget: number =
+      asNumber(p.assistantToolBudget) ?? ASSISTANT_TOOL_BUDGET
+    const userBudget: number = asNumber(p.userBudget) ?? USER_BUDGET
+
+    function shouldExcludeMessage(message: Message): boolean {
+      if (message.tags?.includes('INSTRUCTIONS_PROMPT')) return true
+      if (message.tags?.includes('STEP_PROMPT')) return true
+      if (message.tags?.includes('SUBAGENT_SPAWN')) return true
+      return false
+    }
+
+    function isConversationSummary(message: Message): boolean {
+      if (message.role !== 'user') return false
+      return getTextContent(message).includes('<conversation_summary>')
+    }
+
+    function extractSummaryContent(message: Message): string {
+      const text = getTextContent(message)
+      const match = text.match(
+        /<conversation_summary>([\s\S]*?)<\/conversation_summary>/,
+      )
+      if (!match) return ''
+      let content = match[1].trim()
+      if (content.startsWith(SUMMARY_HEADER)) {
+        content = content.slice(SUMMARY_HEADER.length).trim()
+      }
+      const memoryMatch = content.match(
+        /<historical_memory>([\s\S]*?)<\/historical_memory>/,
+      )
+      if (memoryMatch) {
+        content = memoryMatch[1].trim()
+      }
+      return content
+    }
+
+    /**
+     * Parses a previous summary text blob into role-tagged entries.
+     * Splits on the --- separator and determines each chunk's role
+     * based on its prefix marker.
+     */
+    function parseSummaryIntoEntries(
+      summaryText: string,
+    ): Array<{ role: 'user' | 'assistant_tool'; parts: string[] }> {
+      if (!summaryText.trim()) return []
+
+      const separator = '\n\n---\n\n'
+      const chunks = summaryText.split(separator).filter((c) => c.trim())
+
+      return chunks.map((chunk) => {
+        const trimmed = chunk.trim()
+        const isUser =
+          trimmed.startsWith('[USER]') ||
+          trimmed.startsWith('User request') ||
+          trimmed.startsWith('User message') ||
+          trimmed.startsWith('Current unresolved user request')
+        return {
+          role: isUser ? ('user' as const) : ('assistant_tool' as const),
+          parts: [trimmed],
+        }
+      })
+    }
+
+    // Extract previous summary content from all messages
+    let previousSummaryContent = ''
+    for (const message of currentMessages) {
+      if (isConversationSummary(message)) {
+        previousSummaryContent = extractSummaryContent(message)
+      }
+    }
+
+    // If pruning happens before the assistant has started responding to the
+    // current user prompt, preserve that prompt as a real message after the
+    // memory artifact. If pruning happens mid-turn, keep the prompt in the
+    // historical memory with the assistant/tool progress that followed it and
+    // append a synthetic continuation prompt instead.
+    const latestLiveUserPromptIndex = currentMessages.findLastIndex((message) =>
+      message.tags?.includes('USER_PROMPT'),
+    )
+    const latestLiveUserPromptMessage =
+      latestLiveUserPromptIndex !== -1
+        ? currentMessages[latestLiveUserPromptIndex]
+        : null
+    const isMidTurnPrune =
+      latestLiveUserPromptIndex !== -1 &&
+      currentMessages
+        .slice(latestLiveUserPromptIndex + 1)
+        .some(
+          (message) =>
+            !shouldExcludeMessage(message) && !isConversationSummary(message),
+        )
+
+    // Filter out excluded, conversation summary, and live-prompt messages for summarization
+    const messagesToSummarize = currentMessages
+      .filter(
+        (_message, index) =>
+          isMidTurnPrune || index !== latestLiveUserPromptIndex,
+      )
+      .filter(
+        (message) =>
+          !shouldExcludeMessage(message) && !isConversationSummary(message),
+      )
+
+    // Find the last user message with images to preserve in the final output
+    let lastUserImageParts: Array<ImagePart | FilePart> = []
+    for (let i = messagesToSummarize.length - 1; i >= 0; i--) {
+      const msg = messagesToSummarize[i]
+      if (msg.role === 'user' && Array.isArray(msg.content)) {
+        const imageParts = msg.content.filter(
+          (part): part is ImagePart | FilePart =>
+            part.type === 'image' || part.type === 'file',
+        )
+        if (imageParts.length > 0) {
+          lastUserImageParts = imageParts
+          break
+        }
+      }
+    }
+
+    // Phase 1: Summarize ALL messages into tagged entries
+    type SummaryEntry = {
+      role: 'user' | 'assistant_tool'
+      parts: string[]
+    }
+    const summarizedEntries: SummaryEntry[] = []
+    let liveUserPromptEntry: SummaryEntry | undefined
+
+    for (const message of messagesToSummarize) {
+      if (message.role === 'user') {
+        let text = getTextContent(message).trim()
+        if (text) {
+          text = truncateLongText(text, USER_MESSAGE_LIMIT * CHARS_PER_TOKEN)
+          let hasImages = false
+          if (Array.isArray(message.content)) {
+            hasImages = message.content.some(
+              (part): part is ImagePart | FilePart =>
+                part.type === 'image' || part.type === 'file',
+            )
+          }
+          const imageNote = hasImages ? ' [image(s) were attached]' : ''
+          const entry: SummaryEntry = {
+            role: 'user',
+            parts: [`[USER]${imageNote}\n${text}`],
+          }
+          if (message === latestLiveUserPromptMessage) {
+            liveUserPromptEntry = entry
+          }
+          summarizedEntries.push(entry)
+        }
+      } else if (message.role === 'assistant') {
+        const textParts: string[] = []
+        const toolSummaries: string[] = []
+
+        if (Array.isArray(message.content)) {
+          for (const part of message.content) {
+            if (part.type === 'text' && typeof part.text === 'string') {
+              const textWithoutThinkTags = part.text
+                .replace(/<think>[\s\S]*?<\/think>/g, '')
+                .trim()
+              if (textWithoutThinkTags) {
+                textParts.push(textWithoutThinkTags)
+              }
+            } else if (part.type === 'tool-call') {
+              const toolName = part.toolName
+              const input = asObject(part.input) ?? {}
+              toolSummaries.push(summarizeToolCall(toolName, input))
+            }
+          }
+        }
+
+        const parts: string[] = []
+        if (textParts.length > 0) {
+          let combinedText = textParts.join('\n')
+          combinedText = truncateLongText(
+            combinedText,
+            ASSISTANT_MESSAGE_LIMIT * CHARS_PER_TOKEN,
+          )
+          parts.push(`Progress note:\n${combinedText}`)
+        }
+        if (toolSummaries.length > 0) {
+          parts.push(toolSummaries.join('\n'))
+        }
+
+        if (parts.length > 0) {
+          summarizedEntries.push({
+            role: 'assistant_tool',
+            parts,
+          })
+        }
+      } else if (message.role === 'tool') {
+        const toolMessage: ToolMessage = message
+        const entryParts: string[] = []
+
+        if (Array.isArray(toolMessage.content)) {
+          for (const part of toolMessage.content) {
+            if (part.type === 'json' && part.value) {
+              const value = asObject(part.value)
+              if (!value) continue
+
+              if (value.errorMessage || value.error) {
+                let errorText = String(value.errorMessage || value.error)
+                if (errorText.length > 100) {
+                  errorText = errorText.slice(0, 100) + '...'
+                }
+                entryParts.push(
+                  `Tool error from ${toolMessage.toolName}: ${errorText}`,
+                )
+              }
+
+              if (
+                toolMessage.toolName === 'run_terminal_command' &&
+                'exitCode' in value
+              ) {
+                const exitCode = asNumber(value.exitCode)
+                if (exitCode !== 0) {
+                  entryParts.push(`Command failed with exit code: ${exitCode}`)
+                }
+              }
+
+              if (toolMessage.toolName === 'ask_user') {
+                if (value.skipped) {
+                  entryParts.push('User skipped question')
+                } else if ('answers' in value) {
+                  const answers = asAnswerList(value.answers)
+                  if (answers && answers.length > 0) {
+                    const answerTexts = answers
+                      .map((a) => {
+                        if (a.otherText) return a.otherText
+                        if (a.selectedOptions)
+                          return a.selectedOptions.join(', ')
+                        if (a.selectedOption) return a.selectedOption
+                        return '(no answer)'
+                      })
+                      .join('; ')
+                    const truncated =
+                      answerTexts.length > 10_000
+                        ? answerTexts.slice(0, 10_000) + '...'
+                        : answerTexts
+                    entryParts.push(`User answered: ${truncated}`)
+                  }
+                }
+              }
+
+              if (
+                toolMessage.toolName === 'str_replace' ||
+                toolMessage.toolName === 'propose_str_replace' ||
+                toolMessage.toolName === 'write_file' ||
+                toolMessage.toolName === 'propose_write_file'
+              ) {
+                const resultStr = JSON.stringify(value)
+                const truncatedResult =
+                  resultStr.length > 2000
+                    ? resultStr.slice(0, 2000) + '...'
+                    : resultStr
+                entryParts.push(
+                  `Edit result from ${toolMessage.toolName}:\n${truncatedResult}`,
+                )
+              }
+            }
+          }
+        }
+
+        if (
+          toolMessage.toolName === 'spawn_agents' &&
+          Array.isArray(toolMessage.content)
+        ) {
+          for (const part of toolMessage.content) {
+            if (part.type === 'json' && Array.isArray(part.value)) {
+              const agentResults = asAgentResultList(part.value)
+              if (!agentResults) continue
+              const includedResults = agentResults.filter(
+                (r) =>
+                  r.agentType &&
+                  !SPAWN_AGENTS_OUTPUT_BLACKLIST.includes(r.agentType),
+              )
+              if (includedResults.length > 0) {
+                const resultSummaries = includedResults.map((r) => {
+                  let outputStr = ''
+                  if (r.value?.value !== undefined && r.value?.value !== null) {
+                    if (typeof r.value.value === 'string') {
+                      outputStr = r.value.value
+                    } else {
+                      outputStr = JSON.stringify(r.value.value)
+                    }
+                    outputStr = outputStr
+                      .replace(/<think>[\s\S]*?<\/think>/g, '')
+                      .trim()
+                    if (
+                      outputStr.length >
+                      ASSISTANT_MESSAGE_LIMIT * CHARS_PER_TOKEN
+                    ) {
+                      outputStr =
+                        outputStr.slice(
+                          0,
+                          ASSISTANT_MESSAGE_LIMIT * CHARS_PER_TOKEN,
+                        ) + '...'
+                    }
+                  }
+                  return `- ${r.agentType}: ${outputStr || '(no output)'}`
+                })
+                entryParts.push(`Agent results:\n${resultSummaries.join('\n')}`)
+              }
+            }
+          }
+        }
+
+        if (entryParts.length > 0) {
+          const joinedToolEntry = truncateLongText(
+            entryParts.join('\n\n'),
+            TOOL_ENTRY_LIMIT * CHARS_PER_TOKEN,
+          )
+          summarizedEntries.push({
+            role: 'assistant_tool',
+            parts: [joinedToolEntry],
+          })
+        }
+      }
+    }
+
+    // Parse previous summary into role-tagged entries and combine with new entries
+    const previousSummaryEntries = parseSummaryIntoEntries(
+      previousSummaryContent,
+    )
+    const allEntries: SummaryEntry[] = [
+      ...previousSummaryEntries,
+      ...summarizedEntries,
+    ]
+
+    // Phase 2: Walk backwards through all entries to apply token budgets.
+    // Exhausting one role's budget must not evict entries from the other role:
+    // user prompts are protected by the user budget independently of how much
+    // assistant/tool history the conversation accumulated, and vice versa.
+    let assistantToolTokens = 0
+    let userTokens = 0
+    let assistantToolBudgetExhausted = false
+    let userBudgetExhausted = false
+    const includedEntries: typeof allEntries = []
+
+    for (let i = allEntries.length - 1; i >= 0; i--) {
+      const entry = allEntries[i]
+      const entryText = entry.parts.join('\n\n---\n\n')
+      const entryTokens = Math.ceil(entryText.length / CHARS_PER_TOKEN)
+
+      if (entry.role === 'user') {
+        if (userBudgetExhausted) continue
+        if (userTokens + entryTokens > userBudget) {
+          userBudgetExhausted = true
+          continue
+        }
+        userTokens += entryTokens
+      } else {
+        if (assistantToolBudgetExhausted) continue
+        if (assistantToolTokens + entryTokens > assistantToolBudget) {
+          assistantToolBudgetExhausted = true
+          continue
+        }
+        assistantToolTokens += entryTokens
+      }
+
+      includedEntries.push(entry)
+    }
+
+    // Preserve the pre-existing guarantee that the newest entry always
+    // survives, even when it alone exceeds its role's budget. With independent
+    // role selection, entries from the other role may still fit, so the old
+    // "summary is empty" fallback is no longer sufficient.
+    const newestEntry = allEntries[allEntries.length - 1]
+    let newestEntryForced = false
+    if (newestEntry && !includedEntries.includes(newestEntry)) {
+      // includedEntries is reverse-chronological until Phase 3.
+      includedEntries.unshift(newestEntry)
+      newestEntryForced = true
+    }
+
+    // Phase 3: Build final summary from included entries
+    const summaryParts: string[] = []
+
+    for (let i = includedEntries.length - 1; i >= 0; i--) {
+      summaryParts.push(...includedEntries[i].parts)
+    }
+
+    const summaryText = summaryParts.join('\n\n---\n\n')
+
+    // Create the summarized message with fresh sentAt timestamp
+    // Include any images from the last user message that had images
+    const now = Date.now()
+    const textPart: TextPart = {
+      type: 'text',
+      text: `<conversation_summary>
+${SUMMARY_HEADER}
+
+<historical_memory>
+${summaryText}
+</historical_memory>
+</conversation_summary>
+
+${SUMMARY_DISCLAIMER}`,
+    }
+    // Build content array with text and any preserved images
+    const summaryContentParts: (TextPart | ImagePart | FilePart)[] = [textPart]
+    // Append image parts (they're already typed correctly from the original message)
+    for (const part of lastUserImageParts) {
+      summaryContentParts.push(part)
+    }
+    const summarizedMessage: UserMessage = {
+      role: 'user',
+      content: summaryContentParts,
+      sentAt: now,
+    }
+
+    const continuationMessage: UserMessage = {
+      role: 'user',
+      content: [
+        {
+          type: 'text',
+          text: 'Continue the existing assistant turn from the historical memory above. The original user request and completed assistant/tool work are recorded there. Do not restart completed work; resume with the next necessary real tool call or final response.',
+        },
+      ],
+      sentAt: now,
+    }
+
+    // Build final messages array: summary first, then INSTRUCTIONS_PROMPT if it
+    // exists, then either the live user prompt or a mid-turn continuation prompt.
+    // Keeping a real user message last makes the next model step continue from
+    // normal user input instead of the condensed memory format.
+    const finalMessages: Message[] = [summarizedMessage]
+    if (instructionsPromptMessage) {
+      // Update sentAt to current time so future cache miss checks use fresh timestamps
+      finalMessages.push({ ...instructionsPromptMessage, sentAt: now })
+    }
+    if (isMidTurnPrune) {
+      finalMessages.push(continuationMessage)
+    } else if (latestLiveUserPromptMessage) {
+      finalMessages.push({ ...latestLiveUserPromptMessage, sentAt: now })
+    }
+
+    const userEntryCount = allEntries.filter(
+      (entry) => entry.role === 'user',
+    ).length
+    const assistantToolEntryCount = allEntries.length - userEntryCount
+    const liveUserPromptHasText = latestLiveUserPromptMessage
+      ? getTextContent(latestLiveUserPromptMessage).trim().length > 0
+      : false
+    const liveUserPromptTextPreserved = latestLiveUserPromptMessage
+      ? !isMidTurnPrune ||
+        !liveUserPromptHasText ||
+        (liveUserPromptEntry !== undefined &&
+          includedEntries.includes(liveUserPromptEntry))
+      : false
+    const includedUserEntryCount = includedEntries.filter(
+      (entry) => entry.role === 'user',
+    ).length
+    const includedAssistantToolEntryCount =
+      includedEntries.length - includedUserEntryCount
+    const triggerReason = contextLimitExceeded
+      ? cacheWillMiss
+        ? 'context_limit_and_cache_expiry'
+        : 'context_limit'
+      : 'cache_expiry'
+
+    // Telemetry is best-effort and must never block the actual pruning update.
+    try {
+      logger.info(
+        {
+          axiomEvent: CONTEXT_PRUNING_COMPLETED_EVENT,
+          agent_run_id: agentState.runId ?? null,
+          parent_agent_run_id: agentState.parentId ?? null,
+          trigger_reason: triggerReason,
+          context_token_count: agentState.contextTokenCount,
+          max_context_length: maxContextLength,
+          ...(cacheGapMs === null ? {} : { cache_gap_ms: cacheGapMs }),
+          cache_expiry_ms: CACHE_EXPIRY_MS,
+          previous_summary_entry_count: previousSummaryEntries.length,
+          user_budget: userBudget,
+          user_entry_count: userEntryCount,
+          dropped_user_entry_count: userEntryCount - includedUserEntryCount,
+          assistant_tool_budget: assistantToolBudget,
+          assistant_tool_entry_count: assistantToolEntryCount,
+          dropped_assistant_tool_entry_count:
+            assistantToolEntryCount - includedAssistantToolEntryCount,
+          mid_turn: isMidTurnPrune,
+          live_user_prompt_found: latestLiveUserPromptMessage !== null,
+          live_user_prompt_text_preserved: liveUserPromptTextPreserved,
+          newest_entry_forced: newestEntryForced,
+          summary_estimated_tokens: Math.ceil(
+            summaryText.length / CHARS_PER_TOKEN,
+          ),
+        },
+        'Context pruning completed',
+      )
+    } catch {
+      // Ignore logging failures; set_messages below is the critical operation.
+    }
+
+    yield {
+      toolName: 'set_messages',
+      input: {
+        messages: finalMessages,
+      },
+      includeToolCall: false,
+    } satisfies ToolCall<'set_messages'>
+  },
+}
+
+export default definition