Primera fase context

src/orchestrator/engine.py

@@ -13,6 +13,7 @@ from typing import Any
 from ..adapters.base import ModelAdapter
 from ..config import settings
 from ..context.engine import ContextEngine
+from ..context.compactor import estimate_tokens
 from ..mcp.manager import MCPManager
 from ..memory.store import MemoryStore
 from ..models.agent import AgentProfile
@@ -132,21 +133,19 @@ class OrchestratorEngine:
         usage = result.get("usage", {"input_tokens": 0, "output_tokens": 0})
         key_data = self._extract_key_data_from_results([result])
 
-        session.task_history.append({
-            "task_id": task.task_id,
-            "objective": message,
-            "agent_id": session.agent_id,
-            "status": "completed",
-            "steps": 1,
-            "facts": task.facts_extracted[-10:],
-            "key_data": key_data,
-            "tools_used": [te.tool_name for te in result.get("tool_executions", [])],
-            "artifacts_count": len(result.get("artifacts", [])),
-            "summary": f"User: {message[:150]} → Agent: {content[:150]}",
-            "review": "",
-        })
-        if len(session.task_history) > 20:
-            session.task_history = session.task_history[-20:]
+        session.task_history.append(
+            self._build_task_history_entry(
+                task_id=task.task_id,
+                message=message,
+                content=content,
+                agent_id=session.agent_id,
+                facts=task.facts_extracted,
+                key_data=key_data,
+                tool_executions=result.get("tool_executions", []),
+                artifacts_count=len(result.get("artifacts", [])),
+            )
+        )
+        session.task_history = self._trim_task_history(session.task_history)
 
         # Clean old artifacts
         artifacts = await self.memory.list_artifacts(session.session_id)
@@ -252,3 +251,70 @@ class OrchestratorEngine:
         if seen_modules:
             key_data["modules"] = seen_modules[:20]
         return key_data
+
+    @staticmethod
+    def _build_task_history_entry(
+        task_id: str,
+        message: str,
+        content: str,
+        agent_id: str,
+        facts: list[str],
+        key_data: dict[str, Any],
+        tool_executions: list[Any],
+        artifacts_count: int,
+    ) -> dict[str, Any]:
+        message_summary = " ".join(message.strip().split())[:120]
+        content_summary = " ".join(content.strip().split())[:160]
+        if content_summary:
+            summary = f"User: {message_summary} → Agent: {content_summary}"
+        else:
+            summary = f"User: {message_summary}"
+
+        tools_used: list[str] = []
+        for tool_exec in tool_executions:
+            tool_name = getattr(tool_exec, "tool_name", "")
+            if tool_name and tool_name not in tools_used:
+                tools_used.append(tool_name)
+
+        return {
+            "task_id": task_id,
+            "objective": message[:200],
+            "agent_id": agent_id,
+            "status": "completed",
+            "steps": 1,
+            "facts": facts[-5:],
+            "key_data": key_data,
+            "tools_used": tools_used[:8],
+            "artifacts_count": artifacts_count,
+            "summary": summary,
+            "review": "",
+        }
+
+    @staticmethod
+    def _trim_task_history(history: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        if not history:
+            return []
+
+        trimmed = history[-settings.task_history_max_entries:]
+        kept: list[dict[str, Any]] = []
+        total_tokens = 0
+
+        for entry in reversed(trimmed):
+            entry_tokens = OrchestratorEngine._estimate_task_history_entry_tokens(entry)
+            if kept and total_tokens + entry_tokens > settings.task_history_max_tokens:
+                break
+            kept.append(entry)
+            total_tokens += entry_tokens
+
+        return list(reversed(kept))
+
+    @staticmethod
+    def _estimate_task_history_entry_tokens(entry: dict[str, Any]) -> int:
+        parts = [
+            entry.get("objective", ""),
+            entry.get("summary", ""),
+            " ".join(entry.get("facts", [])[:5]),
+            " ".join(entry.get("tools_used", [])[:5]),
+            str(entry.get("key_data", {})),
+        ]
+        return estimate_tokens("\n".join(p for p in parts if p))