@johpaz/hive 1.7.2 → 1.7.3

package/packages/core/src/agent/context-compiler.ts

@@ -1,544 +0,0 @@
-/**
- * Context Compiler — Implementa las 4 estrategias de Context Engineering:
- * 
- * 1. ESCRIBIR (Write) — Guardar información fuera del contexto:
- *    - Scratchpad: notas persistentes por conversación
- *    - Trazas de ejecución: registro en traces table
- * 
- * 2. SELECCIONAR (Select) — Traer solo lo relevante:
- *    - Tool Loadout: máx 3-5 tools relevantes por turno
- *    - Playbook filtering: reglas ACE aplicables a esta tarea
- *    - Historial selectivo: resumen + mensajes recientes
- * 
- * 3. COMPRIMIR (Compress) — Reducir tokens manteniendo información:
- *    - Compaction: resumir mensajes viejos
- *    - Tool result clearing: reemplazar resultados antiguos por resúmenes
- * 
- * 4. AISLAR (Isolate) — Separar contextos por agente:
- *    - Cada worker recibe su propio contexto mínimo
- *    - El Coordinador ve el panorama completo
- * 
- * TODOS los datos se formatean en TOON para ahorro de tokens.
- */
-
-import { getDb } from "../storage/sqlite"
-import { logger } from "../utils/logger"
-import type { LLMMessage, LLMToolDef } from "./llm-client"
-import type { MCPClientManager } from "@johpaz/hive-mcp"
-import { selectTools, type ToolDescriptor, syncToolCatalogToFTS, syncMCPToolsToFTS, removeMCPToolsFromFTS, mcpToolFullName } from "./tool-selector"
-import { selectSkills, type SkillDescriptor, syncSkillsToFTS } from "./skill-selector"
-import { selectPlaybookRules, syncPlaybookToFTS } from "./playbook-selector"
-import { getRecentMessages, getSummary, getScratchpad, toAPIMessages } from "./conversation-store"
-import { formatContext, estimateTokens } from "../utils/toon"
-import { buildSystemPromptWithProjects } from "./prompt-builder"
-import { createAllTools } from "../tools/index.ts"
-import { resolveUserId } from "../storage/onboarding"
-import { getMCPManager as getSingletonMCPManager } from "../mcp/singleton"
-import { getUserDate, getUserTime } from "../utils/date"
-
-const log = logger.child("context-compiler")
-
-// Configuration constants
-const MAX_TOOL_LOADOUT = 5           // Max tools per turn (Strategy: SELECT)
-const MAX_PLAYBOOK_RULES = 5         // Max ACE rules to inject
-const KEEP_LAST_N_MESSAGES = 10      // Always keep last N messages (Strategy: SELECT)
-const TOKEN_COMPACT_THRESHOLD = 6000 // Compact when exceeds this (Strategy: COMPRESS)
-
-// ─── Tool Expansion ────────────────────────────────────────────────────────
-
-/**
- * Expand selected tools by adding related tools from the same category.
- * This enables multi-step workflows where the LLM needs multiple tools
- * to complete a complex task (e.g., web_search + web_fetch, or browser_navigate + browser_click).
- */
-function expandToolCategories(
-    selected: ToolDescriptor[],
-    allTools: ToolDescriptor[]
-): ToolDescriptor[] {
-    const selectedNames = new Set(selected.map(t => t.name))
-    const expanded = [...selected]
-
-    // Helper to safely add a tool if it exists and isn't already selected
-    const addTool = (name: string) => {
-        if (!selectedNames.has(name)) {
-            const tool = allTools.find(t => t.name === name)
-            if (tool) {
-                expanded.push(tool)
-                selectedNames.add(name)
-            }
-        }
-    }
-
-    // Check for scheduling category → add all cron tools
-    const hasScheduling = selected.some(t => t.category === 'scheduling')
-    if (hasScheduling) {
-        addTool('cron_add')
-        addTool('cron_list')
-        addTool('cron_remove')
-        addTool('cron_edit')
-    }
-
-    // Check for web search → add web_fetch for downloading content
-    const hasWebSearch = selected.some(t => t.name === 'web_search')
-    if (hasWebSearch) {
-        addTool('web_fetch')
-    }
-
-    // Check for browser automation → add all browser tools
-    const hasBrowser = selected.some(t => t.name.startsWith('browser_'))
-    if (hasBrowser) {
-        addTool('browser_navigate')
-        addTool('browser_fetch')
-        addTool('browser_click')
-        addTool('browser_type')
-        addTool('browser_screenshot')
-    }
-
-    // Check for project management → add all project + delegation tools
-    const hasProject = selected.some(t => t.name.startsWith('project_') || t.name.startsWith('task_'))
-    if (hasProject) {
-        addTool('project_create')
-        addTool('project_update')
-        addTool('project_done')
-        addTool('project_fail')
-        addTool('task_create')
-        addTool('task_update')
-        addTool('task_delegate')   // delegation is always paired with project management
-        addTool('agent_find')      // need to find workers before delegating
-        addTool('task_status')
-    }
-
-    // Check for memory operations → add all memory tools
-    const hasMemory = selected.some(t => t.name.startsWith('memory_'))
-    if (hasMemory) {
-        addTool('memory_write')
-        addTool('memory_read')
-        addTool('memory_list')
-        addTool('memory_search')
-        addTool('memory_delete')
-    }
-
-    // Check for agent management → add all agent tools (correct names)
-    const hasAgents = selected.some(t => t.name.startsWith('agent_') || t.name === 'task_delegate')
-    if (hasAgents) {
-        addTool('agent_create')
-        addTool('agent_find')
-        addTool('agent_archive')
-        addTool('task_delegate')
-        addTool('task_status')
-    }
-
-    // Check for canvas → add all canvas tools
-    const hasCanvas = selected.some(t => t.name.startsWith('canvas_'))
-    if (hasCanvas) {
-        addTool('canvas_render')
-        addTool('canvas_ask')
-        addTool('canvas_clear')
-        addTool('canvas_show_card')
-        addTool('canvas_show_progress')
-        addTool('canvas_show_list')
-        addTool('canvas_confirm')
-    }
-
-    // Limit to reasonable number (allow some overflow for multi-step tasks)
-    return expanded.slice(0, MAX_TOOL_LOADOUT + 5)
-}
-
-// ─── Types ─────────────────────────────────────────────────────────────────
-
-// Simple tool interface for context compilation
-export interface ContextTool {
-  name: string
-  description: string
-  parameters: Record<string, unknown>
-  execute?: (params: Record<string, unknown>) => Promise<unknown>
-}
-
-export interface CompiledContext {
-  systemPrompt: string
-  messages: LLMMessage[]
-  tools: LLMToolDef[]
-  allTools: ContextTool[]
-  selectedSkills: SkillDescriptor[]
-}
-
-// ─── Main compiler ─────────────────────────────────────────────────────────
-
-/**
- * Compile context for agent execution implementing 4 strategies:
- *   1. WRITE - Load scratchpad notes
- *   2. SELECT - Tool loadout, playbook rules, selective history
- *   3. COMPRESS - Use summaries, clear old tool results
- *   4. ISOLATE - Worker gets minimal context
- */
-export async function compileContext(opts: {
-  agentId: string
-  threadId: string
-  userId?: string
-  userMessage: string
-  channel?: string
-  isolated?: boolean
-  taskContext?: string
-  mcpManager?: MCPClientManager | null
-}): Promise<CompiledContext> {
-  const db = getDb()
-  const { agentId, threadId, mcpManager, userMessage, isolated } = opts
-
-  // Fallback: Get MCP Manager from singleton if not provided
-  const effectiveMcpManager = mcpManager ?? (() => {
-    const singletonMcp = getSingletonMCPManager()
-    if (singletonMcp) {
-      log.info(`[context-compiler] Using MCP Manager from singleton`)
-      return singletonMcp
-    }
-    return null
-  })()
-  
-  // Resolve userId from database with priority: explicit param → channel identity → single user
-  const userId = opts.userId || resolveUserId({ 
-    threadId, 
-    channel: opts.channel,
-    channelUserId: threadId 
-  }) || threadId || ""
-
-  // [STEP-1] Load agent config
-  log.info(`[context-compiler] [STEP-1] Loading agent config for id=${agentId}`)
-  let agent: any
-  try {
-    agent = db.query<any, [string]>(
-      "SELECT * FROM agents WHERE id = ?"
-    ).get(agentId)
-  } catch (err) {
-    log.error(`[context-compiler] [STEP-1] ❌ FAILED loading agent: ${JSON.stringify(err)}`)
-    throw err
-  }
-
-  if (!agent) {
-    throw new Error(`Agent not found: ${agentId}`)
-  }
-
-  const isWorker = agent.role === 'worker' || isolated
-  log.info(`[context-compiler] [STEP-1] ✅ Compiling for ${isWorker ? 'worker' : 'coordinator'} agent=${agent.name}`)
-
-  // [STEP-2] STRATEGY 1: WRITE — Load scratchpad (persistent notes)
-  log.info(`[context-compiler] [STEP-2] Loading scratchpad...`)
-  let scratchpadNotes: ReturnType<typeof getScratchpad> = []
-  try {
-    scratchpadNotes = getScratchpad(threadId)
-    log.info(`[context-compiler] [STEP-2] ✅ Loaded ${scratchpadNotes.length} scratchpad notes`)
-  } catch (err) {
-    log.error(`[context-compiler] [STEP-2] ❌ FAILED loading scratchpad: ${JSON.stringify(err)}`)
-    throw err
-  }
-
-  // [STEP-3] STRATEGY 2: SELECT — Tool Loadout
-  log.info(`[context-compiler] [STEP-3] Loading tools from DB...`)
-  let dbTools: Array<{ name: string; description: string; category: string; enabled: number; active: number }> = []
-  try {
-    dbTools = db.query<any, []>(`
-      SELECT name, description, category, enabled, active
-      FROM tools
-      WHERE enabled = 1 AND active = 1
-    `).all() as typeof dbTools
-    log.info(`[context-compiler] [STEP-3] ✅ Loaded ${dbTools.length} tools from DB`)
-  } catch (err) {
-    log.error(`[context-compiler] [STEP-3] ❌ FAILED loading tools: ${JSON.stringify(err)}`)
-    throw err
-  }
-
-  // [STEP-3b] Filter by agent assignment (if tools_json is set)
-  let allowedTools = dbTools
-  if (agent.tools_json) {
-    try {
-      const allowedIds = JSON.parse(agent.tools_json) as string[]
-      if (Array.isArray(allowedIds) && allowedIds.length > 0) {
-        allowedTools = dbTools.filter(t => allowedIds.includes(t.name))
-        log.info(`[context-compiler] [STEP-3b] Filtered to ${allowedTools.length} tools assigned to agent`)
-      }
-    } catch (e) {
-      log.warn(`[context-compiler] [STEP-3b] Failed to parse tools_json:`, e)
-    }
-  }
-
-  // Convert native DB tools to ToolDescriptor for FTS5
-  const nativeToolDescriptors: ToolDescriptor[] = allowedTools.map(t => ({
-    name: t.name,
-    description: t.description || "",
-    category: t.category || "core",
-  }))
-
-  // [STEP-3c] Load MCP tools BEFORE FTS selection so they participate in search
-  // MCP tools are dynamic — loaded from the live manager, not from a static catalog.
-  log.info(`[context-compiler] [STEP-3c] Loading MCP tools for FTS selection...`)
-  const mcpToolExecutors: ContextTool[] = []   // full executors (passed to agent)
-  const mcpToolDescriptors: ToolDescriptor[] = [] // lightweight descriptors (for FTS)
-
-  if (effectiveMcpManager) {
-    try {
-      const dbServers = db.query<any, []>(
-        "SELECT id, name, status FROM mcp_servers WHERE enabled = 1"
-      ).all()
-
-      for (const server of dbServers) {
-        // Try ID first (normalized), then name
-        let serverTools = effectiveMcpManager.getServerTools(server.id)
-        if (!serverTools || serverTools.length === 0) {
-          serverTools = effectiveMcpManager.getServerTools(server.name)
-        }
-
-        if (serverTools && serverTools.length > 0) {
-          log.info(`[context-compiler] [STEP-3c] Server ${server.name}: ${serverTools.length} tools`)
-
-          // Sync to FTS5 on every compilation (idempotent — hot-reload keeps FTS fresh)
-          try {
-            await syncMCPToolsToFTS(server.id, server.name, serverTools)
-          } catch (e) {
-            log.warn(`[context-compiler] [STEP-3c] FTS sync failed for ${server.name}: ${(e as Error).message}`)
-          }
-
-          for (const mcpTool of serverTools) {
-            // Sanitized name valid for all LLM providers (no spaces, max 64 chars)
-            const fullName = mcpToolFullName(server.name, mcpTool.name)
-
-            // Executor for agent-loop (has the real call)
-            mcpToolExecutors.push({
-              name: fullName,
-              description: mcpTool.description || `Tool from ${server.name}`,
-              parameters: mcpTool.inputSchema || { type: "object", properties: {} },
-              execute: async (params: Record<string, unknown>) => {
-                const result = await effectiveMcpManager.callTool(server.id, mcpTool.name, params)
-                return typeof result === "string" ? result : JSON.stringify(result)
-              },
-            })
-
-            // Descriptor for FTS selection — uses the same fullName as the executor
-            mcpToolDescriptors.push({
-              name: fullName,
-              description: mcpTool.description || `Tool from ${server.name}`,
-              category: `mcp:${server.id}`,
-            })
-          }
-        } else {
-          log.warn(`[context-compiler] [STEP-3c] Server ${server.name} has no tools (not connected yet)`)
-        }
-      }
-
-      log.info(`[context-compiler] [STEP-3c] ✅ Loaded ${mcpToolExecutors.length} MCP tools`)
-    } catch (err) {
-      log.error(`[context-compiler] [STEP-3c] ❌ Failed: ${(err as Error).message}`)
-    }
-  } else {
-    log.info(`[context-compiler] [STEP-3c] ⚠️ No MCP manager, skipping MCP tools`)
-  }
-
-  // Combined descriptor list: native + MCP — this is what FTS searches
-  const toolDescriptors: ToolDescriptor[] = [...nativeToolDescriptors, ...mcpToolDescriptors]
-
-  // [STEP-4] Level 3: Tool Loadout — select top relevant tools via FTS5
-  // Both native and MCP tools are now searchable
-  log.info(`[context-compiler] [STEP-4] Selecting tools via FTS5 for message: "${userMessage.substring(0, 60)}"`)
-  let selectedToolDescriptors: ToolDescriptor[] = []
-  try {
-    selectedToolDescriptors = selectTools(userMessage, toolDescriptors, MAX_TOOL_LOADOUT)
-    log.info(`[context-compiler] [STEP-4] ✅ Selected ${selectedToolDescriptors.length} tools`)
-  } catch (err) {
-    log.error(`[context-compiler] [STEP-4] ❌ FAILED selectTools (FTS5): ${JSON.stringify(err)}`)
-    throw err
-  }
-
-  // [STEP-4b] Tool Expansion: Auto-add related tools by category
-  selectedToolDescriptors = expandToolCategories(selectedToolDescriptors, toolDescriptors)
-  log.info(`[context-compiler] [STEP-4b] ✅ Expanded to ${selectedToolDescriptors.length} tools`)
-
-  // [STEP-5] STRATEGY 2: SELECT — Playbook rules (ACE)
-  log.info(`[context-compiler] [STEP-5] Selecting playbook rules...`)
-  let playbookRules: ReturnType<typeof selectPlaybookRules> = []
-  try {
-    playbookRules = selectPlaybookRules(userMessage)
-    log.info(`[context-compiler] [STEP-5] ✅ Selected ${playbookRules.length} playbook rules`)
-  } catch (err) {
-    log.error(`[context-compiler] [STEP-5] ❌ FAILED selectPlaybookRules (FTS5): ${JSON.stringify(err)}`)
-    throw err
-  }
-
-  // [STEP-6] STRATEGY 2: SELECT — Skills (dynamic selection)
-  log.info(`[context-compiler] [STEP-6] Selecting skills...`)
-  let selectedSkills: SkillDescriptor[] = []
-  try {
-    selectedSkills = selectSkills(userMessage)
-    log.info(`[context-compiler] [STEP-6] ✅ Selected ${selectedSkills.length} skills`)
-  } catch (err) {
-    log.error(`[context-compiler] [STEP-6] ❌ FAILED selectSkills (FTS5): ${JSON.stringify(err)}`)
-    throw err
-  }
-
-  // [STEP-8] Combine native tools + MCP executors loaded in STEP-3c
-  const config = { tools: {} }
-  const allNativeTools = createAllTools(config)
-  const nativeTools: ContextTool[] = allNativeTools.map(t => ({
-    name: t.name,
-    description: t.description || "",
-    parameters: t.parameters as any,
-    execute: t.execute,
-  }))
-
-  const allTools = [...nativeTools, ...mcpToolExecutors]
-
-  // Filter to only selected tools for this turn
-  const selectedToolNames = new Set(selectedToolDescriptors.map(t => t.name))
-  const filteredTools: ContextTool[] = selectedToolNames.size > 0
-    ? allTools.filter(t => selectedToolNames.has(t.name))
-    : []
-
-  // CRITICAL: search_knowledge is ALWAYS available for coordinator
-  // This tool must never be filtered out
-  const hasSearchKnowledge = allTools.some(t => t.name === "search_knowledge")
-  if (hasSearchKnowledge && !selectedToolNames.has("search_knowledge")) {
-    const searchTool = allTools.find(t => t.name === "search_knowledge")
-    if (searchTool) {
-      filteredTools.push(searchTool)
-      log.info("[context-compiler] ✅ search_knowledge added (critical tool)")
-    }
-  }
-
-  // Convert to LLMToolDef format
-  const toolsForLLM: LLMToolDef[] = filteredTools.map(t => ({
-    type: "function" as const,
-    function: {
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters,
-    },
-  }))
-  log.info(`[context-compiler] [STEP-8] ✅ Combined tools: ${allTools.length} total, ${toolsForLLM.length} selected`)
-
-  // [STEP-9] STRATEGY 3: COMPRESS — Load history with compaction
-  log.info(`[context-compiler] [STEP-9] Loading conversation history...`)
-  let recentMessages: ReturnType<typeof getRecentMessages> = []
-  try {
-    recentMessages = getRecentMessages(threadId, KEEP_LAST_N_MESSAGES)
-    log.info(`[context-compiler] [STEP-9] ✅ Loaded ${recentMessages.length} recent messages`)
-  } catch (err) {
-    log.error(`[context-compiler] [STEP-9] ❌ FAILED loading history: ${JSON.stringify(err)}`)
-    throw err
-  }
-
-  // Check if we need to use summary (conversation is long)
-  let summary: ReturnType<typeof getSummary> = null
-  try {
-    summary = getSummary(threadId)
-  } catch (err) {
-    log.error(`[context-compiler] [STEP-9b] ❌ FAILED loading summary: ${JSON.stringify(err)}`)
-    throw err
-  }
-
-  const totalTokens = recentMessages.reduce((sum, m) => sum + estimateTokens(m.content), 0)
-
-  let messages: LLMMessage[]
-
-  if (summary && totalTokens > TOKEN_COMPACT_THRESHOLD) {
-    // Use summary + recent messages (Strategy: COMPRESS)
-    messages = [
-      { role: "system", content: `[Conversation Summary]: ${summary.summary}` },
-      ...toAPIMessages(recentMessages),
-    ]
-    log.info(`[context-compiler] [STEP-9c] Using summary (${summary.messages_covered} messages compressed)`)
-  } else {
-    // Conversation is short enough, use all recent messages
-    messages = toAPIMessages(recentMessages)
-  }
-
-  // [STEP-10] STRATEGY 4: ISOLATE — Build context based on agent role
-  log.info(`[context-compiler] [STEP-10] Building system prompt...`)
-  let systemPrompt: string
-  try {
-    systemPrompt = await buildSystemPromptWithProjects({ agentId, userId })
-    log.info(`[context-compiler] [STEP-10] ✅ System prompt built (${systemPrompt.length} chars)`)
-  } catch (err) {
-    log.error(`[context-compiler] [STEP-10] ❌ FAILED building system prompt: ${JSON.stringify(err)}`)
-    throw err
-  }
-
-  // [STEP-10b] Inject current date/time (ENTORNO ACTUAL)
-  const userRow = db.query<any, [string]>(
-    "SELECT timezone FROM users WHERE id = ?"
-  ).get(userId)
-  const userTimezone = userRow?.timezone || "UTC"
-  const now = new Date()
-  const fecha = getUserDate(userTimezone, now)
-  const hora = getUserTime(userTimezone, now)
-  systemPrompt += `\n\n# ENTORNO ACTUAL\n**Fecha**: ${fecha}\n**Hora**: ${hora}\n**Zona horaria**: ${userTimezone}\n`
-  log.info(`[context-compiler] [STEP-10b] ✅ Injected current date/time: ${fecha} ${hora} (${userTimezone})`)
-
-  // Inject scratchpad (Strategy: WRITE) — usando TOON para ahorro de tokens
-  if (scratchpadNotes.length > 0) {
-    const scratchpadData: Record<string, string> = {}
-    for (const n of scratchpadNotes) {
-      scratchpadData[n.key] = n.value
-    }
-    // TOON comprime el formato clave-valor
-    const scratchpadContent = formatContext(scratchpadData)
-    systemPrompt += `\n\n# SCRATCHPAD (Persistent Notes)\n${scratchpadContent}\n`
-  }
-
-  // Inject playbook rules (Strategy: SELECT - ACE) — usando TOON
-  if (playbookRules.length > 0) {
-    const rulesByCategory: Record<string, string[]> = {}
-    for (const rule of playbookRules) {
-      const cat = rule.category || "general"
-      if (!rulesByCategory[cat]) rulesByCategory[cat] = []
-      rulesByCategory[cat].push(rule.rule)
-    }
-    // TOON comprime la estructura de categorías y reglas
-    const playbookContent = formatContext(rulesByCategory)
-    systemPrompt += `\n\n# LEARNED PLAYBOOK (ACE)\n${playbookContent}\n`
-  }
-
-  // Inject selected skills — usando TOON
-  if (selectedSkills.length > 0) {
-    const skillsData: Record<string, string> = {}
-    for (const s of selectedSkills) {
-      skillsData[s.name] = s.body || ""
-    }
-
-    // Log skills being injected into context
-    for (const s of selectedSkills) {
-      const bodyPreview = (s.body || "").length > 300
-        ? s.body!.substring(0, 300) + `… (+${s.body!.length - 300} chars)`
-        : (s.body || "(empty)")
-      log.info(`[context-compiler] Skill injected [${s.name}] category=${s.category}: ${bodyPreview}`)
-    }
-
-    // TOON comprime la lista de skills
-    const skillsContent = formatContext(skillsData)
-    systemPrompt += `\n\n## ACTIVE SKILLS\n${skillsContent}\n`
-  }
-
-  // For isolated workers, add task context
-  if (isWorker && opts.taskContext) {
-    systemPrompt += `\n\n# CURRENT TASK\n${opts.taskContext}\n\nFocus ONLY on this task. Do not deviate.`
-  }
-
-  log.info(
-    `[context-compiler] ✅ DONE: ${allTools.length} total, ` +
-    `${toolsForLLM.length} selected tools, ${messages.length} messages, ` +
-    `isolated=${isWorker}`
-  )
-
-  return {
-    systemPrompt,
-    messages,
-    tools: toolsForLLM,
-    allTools,
-    selectedSkills,
-  }
-}
-
-// Re-export sync functions for gateway/initializer
-export { 
-  syncToolCatalogToFTS as syncToolsToFTS, 
-  syncSkillsToFTS, 
-  syncPlaybookToFTS,
-  syncMCPToolsToFTS,
-  removeMCPToolsFromFTS,
-}

package/packages/core/src/agent/context-guard.ts

@@ -1,91 +0,0 @@
-import type { Config } from "../config/loader.ts";
-import { logger } from "../utils/logger.ts";
-import type { LLMMessage as Message } from "../agent/llm-client";
-
-export interface ContextGuardResult {
-  canProceed: boolean;
-  currentTokens: number;
-  maxTokens: number;
-  utilizationPercent: number;
-  needsCompaction: boolean;
-}
-
-export class ContextGuard {
-  private config: Config;
-  private log = logger.child("context-guard");
-
-  constructor(config: Config) {
-    this.config = config;
-  }
-
-  estimateTokens(messages: Message[]): number {
-    let total = 0;
-
-    for (const msg of messages) {
-      total += Math.ceil(msg.content.length / 4);
-
-      if (msg.name) {
-        total += Math.ceil(msg.name.length / 4);
-      }
-
-      if (msg.tool_calls) {
-        for (const tc of msg.tool_calls) {
-          total += Math.ceil(tc.function.name.length / 4);
-          total += Math.ceil(tc.function.arguments.length / 4);
-        }
-      }
-    }
-
-    return total;
-  }
-
-  check(messages: Message[], systemPrompt?: string): ContextGuardResult {
-    const maxTokens = this.config.agent?.context?.maxTokens || 128000;
-    const threshold = this.config.agent?.context?.compactionThreshold || 0.8;
-
-    let currentTokens = this.estimateTokens(messages);
-
-    if (systemPrompt) {
-      currentTokens += Math.ceil(systemPrompt.length / 4);
-    }
-
-    currentTokens += 500;
-
-    const utilizationPercent = currentTokens / maxTokens;
-    const needsCompaction = utilizationPercent >= threshold;
-    const canProceed = currentTokens < maxTokens * 0.95;
-
-    this.log.debug(`Context check: ${currentTokens}/${maxTokens} tokens (${(utilizationPercent * 100).toFixed(1)}%)`);
-
-    return {
-      canProceed,
-      currentTokens,
-      maxTokens,
-      utilizationPercent,
-      needsCompaction,
-    };
-  }
-
-  shouldCompact(messages: Message[], systemPrompt?: string): boolean {
-    const result = this.check(messages, systemPrompt);
-    return result.needsCompaction;
-  }
-
-  getRecommendedAction(messages: Message[], systemPrompt?: string): "proceed" | "compact" | "error" {
-    const result = this.check(messages, systemPrompt);
-
-    if (result.utilizationPercent >= 0.95) {
-      return "error";
-    }
-
-    if (result.needsCompaction) {
-      return "compact";
-    }
-
-    return "proceed";
-  }
-}
-
-export function createContextGuard(config: Config): ContextGuard {
-  return new ContextGuard(config);
-}