feat: tool fixation detection — break repetitive loops (#886)

Marathon sessions show tool fixation: agent latches onto one tool
and calls it repeatedly. Observed streaks of 8-25 identical calls.

New agent/tool_fixation_detector.py:
- ToolFixationDetector: tracks consecutive tool calls
- record(tool_name): returns nudge prompt when threshold reached
- Default threshold: 5 consecutive calls (configurable via
  TOOL_FIXATION_THRESHOLD env var)
- Nudge prompt explains the fixation and suggests alternatives:
  1. Read error carefully
  2. Try different tool
  3. Ask user for clarification
  4. Check if task is complete
- get_streak_info(): current streak state
- format_report(): human-readable fixation events
- Singleton via get_fixation_detector()

Config:
- TOOL_FIXATION_THRESHOLD (default: 5)
- TOOL_FIXATION_WINDOW (default: 10)

Tests: tests/test_tool_fixation_detector.py (9 tests)

Closes #886

agent/token_budget.py

@@ -1,165 +0,0 @@
-"""Token Budget — Poka-yoke guard against context overflow.
-
-Progressive warning system with circuit breakers:
-- 60%: Log warning, suggest summarization
-- 80%: Auto-compress, drop raw tool outputs
-- 90%: Block verbose tools, force wrap-up
-- 95%: Graceful termination with summary
-
-Usage:
-    from agent.token_budget import TokenBudget
-    budget = TokenBudget(max_tokens=128000)
-    budget.record_usage(prompt_tokens=500, completion_tokens=200)
-    status = budget.check()
-    # status.level: ok, warning, compress, block, terminate
-"""
-
-from __future__ import annotations
-
-import logging
-import time
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Dict, List, Optional
-
-logger = logging.getLogger(__name__)
-
-
-class BudgetLevel(Enum):
-    """Token budget alert levels."""
-    OK = "ok"                 # < 60%
-    WARNING = "warning"       # 60-80%
-    COMPRESS = "compress"     # 80-90%
-    BLOCK = "block"           # 90-95%
-    TERMINATE = "terminate"   # > 95%
-
-
-@dataclass
-class BudgetStatus:
-    """Current budget status."""
-    level: BudgetLevel
-    used_tokens: int
-    max_tokens: int
-    percentage: float
-    remaining: int
-    message: str
-    actions: List[str] = field(default_factory=list)
-
-
-# Default thresholds
-THRESHOLDS = {
-    BudgetLevel.WARNING: 0.60,
-    BudgetLevel.COMPRESS: 0.80,
-    BudgetLevel.BLOCK: 0.90,
-    BudgetLevel.TERMINATE: 0.95,
-}
-
-
-class TokenBudget:
-    """Track token usage and enforce context limits."""
-
-    def __init__(self, max_tokens: int = 128000,
-                 thresholds: Optional[Dict[BudgetLevel, float]] = None):
-        self._max_tokens = max_tokens
-        self._thresholds = thresholds or THRESHOLDS
-        self._prompt_tokens = 0
-        self._completion_tokens = 0
-        self._tool_output_tokens = 0
-        self._history: List[Dict[str, Any]] = []
-
-    @property
-    def used_tokens(self) -> int:
-        return self._prompt_tokens + self._completion_tokens
-
-    @property
-    def remaining(self) -> int:
-        return max(0, self._max_tokens - self.used_tokens)
-
-    @property
-    def percentage(self) -> float:
-        if self._max_tokens == 0:
-            return 0
-        return self.used_tokens / self._max_tokens
-
-    def record_usage(self, prompt_tokens: int = 0, completion_tokens: int = 0,
-                     tool_output_tokens: int = 0):
-        """Record token usage from an API call."""
-        self._prompt_tokens += prompt_tokens
-        self._completion_tokens += completion_tokens
-        self._tool_output_tokens += tool_output_tokens
-        self._history.append({
-            "time": time.time(),
-            "prompt": prompt_tokens,
-            "completion": completion_tokens,
-            "tool_output": tool_output_tokens,
-            "total_used": self.used_tokens,
-        })
-
-    def check(self) -> BudgetStatus:
-        """Check current budget status and return appropriate actions."""
-        pct = self.percentage
-
-        if pct >= self._thresholds.get(BudgetLevel.TERMINATE, 0.95):
-            level = BudgetLevel.TERMINATE
-            msg = f"Context {pct:.0%} full. Session must terminate with summary."
-            actions = ["generate_summary", "terminate_session"]
-        elif pct >= self._thresholds.get(BudgetLevel.BLOCK, 0.90):
-            level = BudgetLevel.BLOCK
-            msg = f"Context {pct:.0%} full. Blocking verbose tool calls."
-            actions = ["block_verbose_tools", "force_wrap_up", "suggest_summary"]
-        elif pct >= self._thresholds.get(BudgetLevel.COMPRESS, 0.80):
-            level = BudgetLevel.COMPRESS
-            msg = f"Context {pct:.0%} full. Auto-compressing conversation."
-            actions = ["auto_compress", "drop_raw_tool_outputs", "suggest_summary"]
-        elif pct >= self._thresholds.get(BudgetLevel.WARNING, 0.60):
-            level = BudgetLevel.WARNING
-            msg = f"Context {pct:.0%} used. Consider summarizing."
-            actions = ["suggest_summary", "log_warning"]
-        else:
-            level = BudgetLevel.OK
-            msg = f"Context OK: {self.used_tokens}/{self._max_tokens} tokens ({pct:.0%})"
-            actions = []
-
-        return BudgetStatus(
-            level=level,
-            used_tokens=self.used_tokens,
-            max_tokens=self._max_tokens,
-            percentage=round(pct, 3),
-            remaining=self.remaining,
-            message=msg,
-            actions=actions,
-        )
-
-    def should_truncate_tool_output(self, estimated_tokens: int) -> bool:
-        """Check if a tool output should be truncated."""
-        if self.used_tokens + estimated_tokens > self._max_tokens * 0.95:
-            return True
-        return False
-
-    def get_truncation_budget(self) -> int:
-        """Get max tokens available for next tool output."""
-        budget = self.remaining - int(self._max_tokens * 0.05)  # Reserve 5%
-        return max(0, budget)
-
-    def reset(self):
-        """Reset budget for new session."""
-        self._prompt_tokens = 0
-        self._completion_tokens = 0
-        self._tool_output_tokens = 0
-        self._history.clear()
-
-    def get_report(self) -> Dict[str, Any]:
-        """Generate usage report."""
-        status = self.check()
-        return {
-            "status": status.level.value,
-            "used_tokens": self.used_tokens,
-            "max_tokens": self._max_tokens,
-            "remaining": self.remaining,
-            "percentage": status.percentage,
-            "prompt_tokens": self._prompt_tokens,
-            "completion_tokens": self._completion_tokens,
-            "tool_output_tokens": self._tool_output_tokens,
-            "message": status.message,
-            "actions": status.actions,
-        }

agent/tool_fixation_detector.py

@@ -0,0 +1,156 @@
+"""Tool fixation detection — break repetitive tool calling loops.
+
+Detects when the agent latches onto one tool and calls it repeatedly
+without making progress. Injects a nudge prompt to break the loop.
+
+Usage:
+    from agent.tool_fixation_detector import ToolFixationDetector
+    detector = ToolFixationDetector()
+    nudge = detector.record("execute_code")
+    if nudge:
+        # Inject nudge into conversation
+        messages.append({"role": "system", "content": nudge})
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+
+# Default thresholds
+_DEFAULT_THRESHOLD = int(os.getenv("TOOL_FIXATION_THRESHOLD", "5"))
+_DEFAULT_WINDOW = int(os.getenv("TOOL_FIXATION_WINDOW", "10"))
+
+
+@dataclass
+class FixationEvent:
+    """Record of a fixation detection."""
+    tool_name: str
+    streak_length: int
+    threshold: int
+    nudge_sent: bool = False
+
+
+class ToolFixationDetector:
+    """Detects and breaks tool fixation loops.
+
+    Tracks the sequence of tool calls and detects when the same tool
+    is called N times consecutively. When detected, returns a nudge
+    prompt to inject into the conversation.
+    """
+
+    def __init__(self, threshold: int = 0, window: int = 0):
+        self.threshold = threshold or _DEFAULT_THRESHOLD
+        self.window = window or _DEFAULT_WINDOW
+        self._history: List[str] = []
+        self._current_streak: str = ""
+        self._streak_count: int = 0
+        self._nudges_sent: int = 0
+        self._events: List[FixationEvent] = []
+
+    @property
+    def nudges_sent(self) -> int:
+        return self._nudges_sent
+
+    @property
+    def events(self) -> List[FixationEvent]:
+        return list(self._events)
+
+    def record(self, tool_name: str) -> Optional[str]:
+        """Record a tool call and return nudge prompt if fixation detected.
+
+        Args:
+            tool_name: Name of the tool that was called.
+
+        Returns:
+            Nudge prompt string if fixation detected, None otherwise.
+        """
+        self._history.append(tool_name)
+
+        # Trim history to window
+        if len(self._history) > self.window:
+            self._history = self._history[-self.window:]
+
+        # Update streak
+        if tool_name == self._current_streak:
+            self._streak_count += 1
+        else:
+            self._current_streak = tool_name
+            self._streak_count = 1
+
+        # Check for fixation
+        if self._streak_count >= self.threshold:
+            event = FixationEvent(
+                tool_name=tool_name,
+                streak_length=self._streak_count,
+                threshold=self.threshold,
+                nudge_sent=True,
+            )
+            self._events.append(event)
+            self._nudges_sent += 1
+
+            return self._build_nudge(tool_name, self._streak_count)
+
+        return None
+
+    def _build_nudge(self, tool_name: str, count: int) -> str:
+        """Build a nudge prompt to break the fixation loop."""
+        return (
+            f"[SYSTEM: You have called `{tool_name}` {count} times in a row "
+            f"without switching tools. This suggests a fixation loop. "
+            f"Consider:\n"
+            f"1. Is the tool returning an error? Read the error carefully.\n"
+            f"2. Is there a different tool that could help?\n"
+            f"3. Should you ask the user for clarification?\n"
+            f"4. Is the task actually complete?\n"
+            f"Break the loop by trying a different approach.]"
+        )
+
+    def reset(self) -> None:
+        """Reset the detector state."""
+        self._history.clear()
+        self._current_streak = ""
+        self._streak_count = 0
+
+    def get_streak_info(self) -> dict:
+        """Get current streak information."""
+        return {
+            "current_tool": self._current_streak,
+            "streak_count": self._streak_count,
+            "threshold": self.threshold,
+            "at_threshold": self._streak_count >= self.threshold,
+            "nudges_sent": self._nudges_sent,
+        }
+
+    def format_report(self) -> str:
+        """Format fixation events as a report."""
+        if not self._events:
+            return "No tool fixation detected."
+
+        lines = [
+            f"Tool Fixation Report ({len(self._events)} events)",
+            "=" * 40,
+        ]
+        for e in self._events:
+            lines.append(f"  {e.tool_name}: {e.streak_length} consecutive calls (threshold: {e.threshold})")
+        return "\n".join(lines)
+
+
+# Singleton
+_detector: Optional[ToolFixationDetector] = None
+
+
+def get_fixation_detector() -> ToolFixationDetector:
+    """Get or create the singleton detector."""
+    global _detector
+    if _detector is None:
+        _detector = ToolFixationDetector()
+    return _detector
+
+
+def reset_fixation_detector() -> None:
+    """Reset the singleton."""
+    global _detector
+    _detector = None

tests/test_tool_fixation_detector.py

@@ -0,0 +1,76 @@
+"""Tests for tool fixation detection."""
+
+import pytest
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from agent.tool_fixation_detector import ToolFixationDetector, get_fixation_detector
+
+
+class TestFixationDetection:
+    def test_no_fixation_below_threshold(self):
+        d = ToolFixationDetector(threshold=5)
+        for i in range(4):
+            assert d.record("execute_code") is None
+
+    def test_fixation_at_threshold(self):
+        d = ToolFixationDetector(threshold=3)
+        d.record("execute_code")
+        d.record("execute_code")
+        nudge = d.record("execute_code")
+        assert nudge is not None
+        assert "execute_code" in nudge
+        assert "3 times" in nudge
+
+    def test_fixation_above_threshold(self):
+        d = ToolFixationDetector(threshold=3)
+        d.record("execute_code")
+        d.record("execute_code")
+        d.record("execute_code")  # threshold hit
+        nudge = d.record("execute_code")  # still nudging
+        assert nudge is not None
+
+    def test_streak_resets_on_different_tool(self):
+        d = ToolFixationDetector(threshold=3)
+        d.record("execute_code")
+        d.record("execute_code")
+        d.record("terminal")  # breaks streak
+        assert d._streak_count == 1
+        assert d._current_streak == "terminal"
+
+    def test_nudges_sent_counter(self):
+        d = ToolFixationDetector(threshold=2)
+        d.record("a")
+        d.record("a")  # nudge 1
+        d.record("a")  # nudge 2
+        assert d.nudges_sent == 2
+
+    def test_events_recorded(self):
+        d = ToolFixationDetector(threshold=2)
+        d.record("x")
+        d.record("x")
+        assert len(d.events) == 1
+        assert d.events[0].tool_name == "x"
+        assert d.events[0].streak_length == 2
+
+    def test_report(self):
+        d = ToolFixationDetector(threshold=2)
+        d.record("x")
+        d.record("x")
+        report = d.format_report()
+        assert "x" in report
+
+    def test_reset(self):
+        d = ToolFixationDetector(threshold=2)
+        d.record("x")
+        d.record("x")
+        d.reset()
+        assert d._streak_count == 0
+        assert d._current_streak == ""
+
+    def test_singleton(self):
+        d1 = get_fixation_detector()
+        d2 = get_fixation_detector()
+        assert d1 is d2

tools/skill_manager_tool.py

@@ -44,34 +44,6 @@ from typing import Dict, Any, Optional, Tuple
 
 logger = logging.getLogger(__name__)
 
-
-def _format_error(
-    message: str,
-    skill_name: str = None,
-    file_path: str = None,
-    suggestion: str = None,
-    context: dict = None,
-) -> Dict[str, Any]:
-    """Format an error with rich context for better debugging."""
-    parts = [message]
-    if skill_name:
-        parts.append(f"Skill: {skill_name}")
-    if file_path:
-        parts.append(f"File: {file_path}")
-    if suggestion:
-        parts.append(f"Suggestion: {suggestion}")
-    if context:
-        for key, value in context.items():
-            parts.append(f"{key}: {value}")
-    return {
-        "success": False,
-        "error": " | ".join(parts),
-        "skill_name": skill_name,
-        "file_path": file_path,
-        "suggestion": suggestion,
-    }
-
-
 # Import security scanner — agent-created skills get the same scrutiny as
 # community hub installs.
 try: