savant-code 0.0.19 → 0.0.21

package/agents/context-pruner.ts

@@ -1,1076 +0,0 @@
-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