[argus] loop_detector: drop layer-2 frequency detection

Layer 2 counted every call to a tool *name* regardless of args, then
warned at 30 / hard-stopped at 50. The intent (per the docstring) was to
"catch cross-file read loops that hash-based detection misses": model
gets lost, calls read_file across 40 different files, layer 1 doesn't
fire because each call has a distinct key. In practice it false-positives
on legitimate high-cardinality work — argus thread 5077dd8e (Webfuse
docs audit) tripped the warning twice while crawling distinct URLs, and
the model misread the warning as a hard quota and stopped.

Layer 1 + the edit-aware reset shipped in 3bac95e are now strong enough
to handle the verifier-iteration false positive that originally pushed
us toward layer 2 as a backstop. The remaining layer-2-only signal
(genuine cross-arg drift) is rare on a single-user local box and the
recursion limit catches the truly pathological cases.

Removes:
  - _DEFAULT_TOOL_FREQ_WARN / _DEFAULT_TOOL_FREQ_HARD_LIMIT constants
  - _TOOL_FREQ_WARNING_MSG / _TOOL_FREQ_HARD_STOP_MSG constants
  - tool_freq_warn / tool_freq_hard_limit constructor params
  - self._tool_freq / self._tool_freq_warned per-thread state
  - the layer-2 block at the end of _track_and_check
  - TestToolFrequencyDetection (10 tests) plus the LRU-eviction
    assertions on _tool_freq[*]

46 loop-detection tests still pass (was 56; the dropped 10 were all
TestToolFrequencyDetection plus 2 nested LRU asserts).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Nichol4s

backend/packages/harness/deerflow/agents/middlewares/loop_detection_middleware.py

@@ -32,8 +32,6 @@
 _DEFAULT_HARD_LIMIT = 8  # force-stop after 8 identical calls
 _DEFAULT_WINDOW_SIZE = 20  # track last N tool calls
 _DEFAULT_MAX_TRACKED_THREADS = 100  # LRU eviction limit
-_DEFAULT_TOOL_FREQ_WARN = 30  # warn after 30 calls to the same tool type
-_DEFAULT_TOOL_FREQ_HARD_LIMIT = 50  # force-stop after 50 calls to the same tool type
 
 
 def _normalize_tool_call_args(raw_args: object) -> tuple[dict, str | None]:
@@ -171,18 +169,8 @@ def _hash_tool_calls(tool_calls: list[dict]) -> str:
     "If the task genuinely cannot be completed, summarize what you accomplished and stop."
 )
 
-_TOOL_FREQ_WARNING_MSG = (
-    "[REPEAT TOOL CALL DETECTED] You have called {tool_name} {count} times in this conversation. "
-    "Step back: are these calls converging on a result, or are you cycling through similar variations? "
-    "If you are cycling, switch strategy — instrument, reduce the test surface, or pick a clearly different angle. "
-    "Do not rewrite the artifact from scratch; that usually introduces new bugs without fixing the original. "
-    "If the task genuinely cannot be completed, summarize what you accomplished and stop."
-)
-
 _HARD_STOP_MSG = "[FORCED STOP] Repeated tool calls exceeded the safety limit. Producing final answer with results collected so far."
 
-_TOOL_FREQ_HARD_STOP_MSG = "[FORCED STOP] Tool {tool_name} called {count} times — exceeded the per-tool safety limit. Producing final answer with results collected so far."
-
 
 class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
     """Detects and breaks repetitive tool call loops.
@@ -196,12 +184,6 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
             Default: 20.
         max_tracked_threads: Maximum number of threads to track before
             evicting the least recently used. Default: 100.
-        tool_freq_warn: Number of calls to the same tool *type* (regardless
-            of arguments) before injecting a frequency warning. Catches
-            cross-file read loops that hash-based detection misses.
-            Default: 30.
-        tool_freq_hard_limit: Number of calls to the same tool type before
-            forcing a stop. Default: 50.
     """
 
     def __init__(
@@ -210,23 +192,16 @@ def __init__(
         hard_limit: int = _DEFAULT_HARD_LIMIT,
         window_size: int = _DEFAULT_WINDOW_SIZE,
         max_tracked_threads: int = _DEFAULT_MAX_TRACKED_THREADS,
-        tool_freq_warn: int = _DEFAULT_TOOL_FREQ_WARN,
-        tool_freq_hard_limit: int = _DEFAULT_TOOL_FREQ_HARD_LIMIT,
     ):
         super().__init__()
         self.warn_threshold = warn_threshold
         self.hard_limit = hard_limit
         self.window_size = window_size
         self.max_tracked_threads = max_tracked_threads
-        self.tool_freq_warn = tool_freq_warn
-        self.tool_freq_hard_limit = tool_freq_hard_limit
         self._lock = threading.Lock()
         # Per-thread tracking using OrderedDict for LRU eviction
         self._history: OrderedDict[str, list[str]] = OrderedDict()
         self._warned: dict[str, set[str]] = defaultdict(set)
-        # Per-thread, per-tool-type cumulative call counts
-        self._tool_freq: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
-        self._tool_freq_warned: dict[str, set[str]] = defaultdict(set)
         # Per-thread set of paths mutated since the last reset. A subsequent call
         # that references one of these paths clears identical-hash history (the
         # file changed, so re-probing it isn't a loop), and consumes the path so
@@ -248,19 +223,14 @@ def _evict_if_needed(self) -> None:
         while len(self._history) > self.max_tracked_threads:
             evicted_id, _ = self._history.popitem(last=False)
             self._warned.pop(evicted_id, None)
-            self._tool_freq.pop(evicted_id, None)
-            self._tool_freq_warned.pop(evicted_id, None)
             self._mutated_paths.pop(evicted_id, None)
             logger.debug("Evicted loop tracking for thread %s (LRU)", evicted_id)
 
     def _track_and_check(self, state: AgentState, runtime: Runtime) -> tuple[str | None, bool]:
         """Track tool calls and check for loops.
 
-        Two detection layers:
-          1. **Hash-based** (existing): catches identical tool call sets.
-          2. **Frequency-based** (new): catches the same *tool type* being
-             called many times with varying arguments (e.g. ``read_file``
-             on 40 different files).
+        Hash-based detection: identical tool call sets in a sliding window
+        trigger a warning at warn_threshold and a hard stop at hard_limit.
 
         Edit-aware reset: if any tool call references a path that was mutated
         (by a prior write_file/str_replace) since the last reset for that path,
@@ -331,7 +301,6 @@ def _track_and_check(self, state: AgentState, runtime: Runtime) -> tuple[str | N
                 if mp:
                     self._mutated_paths[thread_id].add(mp)
 
-            # --- Layer 1: hash-based (identical call sets) ---
             if count >= self.hard_limit:
                 logger.error(
                     "Loop hard limit reached — forcing stop",
@@ -359,40 +328,6 @@ def _track_and_check(self, state: AgentState, runtime: Runtime) -> tuple[str | N
                     )
                     return _WARNING_MSG, False
 
-            # --- Layer 2: per-tool-type frequency ---
-            freq = self._tool_freq[thread_id]
-            for tc in tool_calls:
-                name = tc.get("name", "")
-                if not name:
-                    continue
-                freq[name] += 1
-                tc_count = freq[name]
-
-                if tc_count >= self.tool_freq_hard_limit:
-                    logger.error(
-                        "Tool frequency hard limit reached — forcing stop",
-                        extra={
-                            "thread_id": thread_id,
-                            "tool_name": name,
-                            "count": tc_count,
-                        },
-                    )
-                    return _TOOL_FREQ_HARD_STOP_MSG.format(tool_name=name, count=tc_count), True
-
-                if tc_count >= self.tool_freq_warn:
-                    warned = self._tool_freq_warned[thread_id]
-                    if name not in warned:
-                        warned.add(name)
-                        logger.warning(
-                            "Tool frequency warning — too many calls to same tool type",
-                            extra={
-                                "thread_id": thread_id,
-                                "tool_name": name,
-                                "count": tc_count,
-                            },
-                        )
-                        return _TOOL_FREQ_WARNING_MSG.format(tool_name=name, count=tc_count), False
-
         return None, False
 
     @staticmethod
@@ -468,12 +403,8 @@ def reset(self, thread_id: str | None = None) -> None:
             if thread_id:
                 self._history.pop(thread_id, None)
                 self._warned.pop(thread_id, None)
-                self._tool_freq.pop(thread_id, None)
-                self._tool_freq_warned.pop(thread_id, None)
                 self._mutated_paths.pop(thread_id, None)
             else:
                 self._history.clear()
                 self._warned.clear()
-                self._tool_freq.clear()
                 self._mutated_paths.clear()
-                self._tool_freq_warned.clear()

backend/tests/test_loop_detection_middleware.py

@@ -328,8 +328,6 @@ def test_lru_eviction(self):
         mw._apply(_make_state(tool_calls=call), runtime_new)
 
         assert "thread-0" not in mw._history
-        assert "thread-0" not in mw._tool_freq
-        assert "thread-0" not in mw._tool_freq_warned
         assert "thread-new" in mw._history
         assert len(mw._history) == 3
 
@@ -501,189 +499,6 @@ def _make_provider_state():
         assert msg.response_metadata["finish_reason"] == "stop"
 
 
-class TestToolFrequencyDetection:
-    """Tests for per-tool-type frequency detection (Layer 2).
-
-    This catches the case where an agent calls the same tool type many times
-    with *different* arguments (e.g. read_file on 40 different files), which
-    bypasses hash-based detection.
-    """
-
-    def _read_call(self, path):
-        return {"name": "read_file", "id": f"call_read_{path}", "args": {"path": path}}
-
-    def test_below_freq_warn_returns_none(self):
-        mw = LoopDetectionMiddleware(tool_freq_warn=5, tool_freq_hard_limit=10)
-        runtime = _make_runtime()
-
-        for i in range(4):
-            result = mw._apply(_make_state(tool_calls=[self._read_call(f"/file_{i}.py")]), runtime)
-            assert result is None
-
-    def test_freq_warn_at_threshold(self):
-        mw = LoopDetectionMiddleware(tool_freq_warn=5, tool_freq_hard_limit=10)
-        runtime = _make_runtime()
-
-        for i in range(4):
-            mw._apply(_make_state(tool_calls=[self._read_call(f"/file_{i}.py")]), runtime)
-
-        # 5th call to read_file (different file each time) triggers freq warning
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/file_4.py")]), runtime)
-        assert result is not None
-        msg = result["messages"][0]
-        assert isinstance(msg, HumanMessage)
-        assert "read_file" in msg.content
-        assert "REPEAT TOOL CALL DETECTED" in msg.content
-
-    def test_freq_warn_only_injected_once(self):
-        mw = LoopDetectionMiddleware(tool_freq_warn=3, tool_freq_hard_limit=10)
-        runtime = _make_runtime()
-
-        for i in range(2):
-            mw._apply(_make_state(tool_calls=[self._read_call(f"/file_{i}.py")]), runtime)
-
-        # 3rd triggers warning
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/file_2.py")]), runtime)
-        assert result is not None
-        assert "REPEAT TOOL CALL DETECTED" in result["messages"][0].content
-
-        # 4th should not re-warn (already warned for read_file)
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/file_3.py")]), runtime)
-        assert result is None
-
-    def test_freq_hard_stop_at_limit(self):
-        mw = LoopDetectionMiddleware(tool_freq_warn=3, tool_freq_hard_limit=6)
-        runtime = _make_runtime()
-
-        for i in range(5):
-            mw._apply(_make_state(tool_calls=[self._read_call(f"/file_{i}.py")]), runtime)
-
-        # 6th call triggers hard stop
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/file_5.py")]), runtime)
-        assert result is not None
-        msg = result["messages"][0]
-        assert isinstance(msg, AIMessage)
-        assert msg.tool_calls == []
-        assert "FORCED STOP" in msg.content
-        assert "read_file" in msg.content
-
-    def test_different_tools_tracked_independently(self):
-        """read_file and bash should have independent frequency counters."""
-        mw = LoopDetectionMiddleware(tool_freq_warn=3, tool_freq_hard_limit=10)
-        runtime = _make_runtime()
-
-        # 2 read_file calls
-        for i in range(2):
-            mw._apply(_make_state(tool_calls=[self._read_call(f"/file_{i}.py")]), runtime)
-
-        # 2 bash calls — should not trigger (bash count = 2, read_file count = 2)
-        for i in range(2):
-            result = mw._apply(_make_state(tool_calls=[_bash_call(f"cmd_{i}")]), runtime)
-            assert result is None
-
-        # 3rd read_file triggers (read_file count = 3)
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/file_2.py")]), runtime)
-        assert result is not None
-        assert "read_file" in result["messages"][0].content
-
-    def test_freq_reset_clears_state(self):
-        mw = LoopDetectionMiddleware(tool_freq_warn=3, tool_freq_hard_limit=10)
-        runtime = _make_runtime()
-
-        for i in range(2):
-            mw._apply(_make_state(tool_calls=[self._read_call(f"/file_{i}.py")]), runtime)
-
-        mw.reset()
-
-        # After reset, count restarts — should not trigger
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/file_new.py")]), runtime)
-        assert result is None
-
-    def test_freq_reset_per_thread_clears_only_target(self):
-        """reset(thread_id=...) should clear frequency state for that thread only."""
-        mw = LoopDetectionMiddleware(tool_freq_warn=3, tool_freq_hard_limit=10)
-        runtime_a = _make_runtime("thread-A")
-        runtime_b = _make_runtime("thread-B")
-
-        # 2 calls on each thread
-        for i in range(2):
-            mw._apply(_make_state(tool_calls=[self._read_call(f"/a_{i}.py")]), runtime_a)
-            mw._apply(_make_state(tool_calls=[self._read_call(f"/b_{i}.py")]), runtime_b)
-
-        # Reset only thread-A
-        mw.reset(thread_id="thread-A")
-
-        assert "thread-A" not in mw._tool_freq
-        assert "thread-A" not in mw._tool_freq_warned
-
-        # thread-B state should still be intact — 3rd call triggers warn
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/b_2.py")]), runtime_b)
-        assert result is not None
-        assert "REPEAT TOOL CALL DETECTED" in result["messages"][0].content
-
-        # thread-A restarted from 0 — should not trigger
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/a_new.py")]), runtime_a)
-        assert result is None
-
-    def test_freq_per_thread_isolation(self):
-        """Frequency counts should be independent per thread."""
-        mw = LoopDetectionMiddleware(tool_freq_warn=3, tool_freq_hard_limit=10)
-        runtime_a = _make_runtime("thread-A")
-        runtime_b = _make_runtime("thread-B")
-
-        # 2 calls on thread A
-        for i in range(2):
-            mw._apply(_make_state(tool_calls=[self._read_call(f"/file_{i}.py")]), runtime_a)
-
-        # 2 calls on thread B — should NOT push thread A over threshold
-        for i in range(2):
-            mw._apply(_make_state(tool_calls=[self._read_call(f"/other_{i}.py")]), runtime_b)
-
-        # 3rd call on thread A — triggers (count=3 for thread A only)
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/file_2.py")]), runtime_a)
-        assert result is not None
-        assert "REPEAT TOOL CALL DETECTED" in result["messages"][0].content
-
-    def test_multi_tool_single_response_counted(self):
-        """When a single response has multiple tool calls, each is counted."""
-        mw = LoopDetectionMiddleware(tool_freq_warn=5, tool_freq_hard_limit=10)
-        runtime = _make_runtime()
-
-        # Response 1: 2 read_file calls → count = 2
-        call = [self._read_call("/a.py"), self._read_call("/b.py")]
-        result = mw._apply(_make_state(tool_calls=call), runtime)
-        assert result is None
-
-        # Response 2: 2 more → count = 4
-        call = [self._read_call("/c.py"), self._read_call("/d.py")]
-        result = mw._apply(_make_state(tool_calls=call), runtime)
-        assert result is None
-
-        # Response 3: 1 more → count = 5 → triggers warn
-        result = mw._apply(_make_state(tool_calls=[self._read_call("/e.py")]), runtime)
-        assert result is not None
-        assert "read_file" in result["messages"][0].content
-
-    def test_hash_detection_takes_priority(self):
-        """Hash-based hard stop fires before frequency check for identical calls."""
-        mw = LoopDetectionMiddleware(
-            warn_threshold=2,
-            hard_limit=3,
-            tool_freq_warn=100,
-            tool_freq_hard_limit=200,
-        )
-        runtime = _make_runtime()
-        call = [self._read_call("/same_file.py")]
-
-        for _ in range(2):
-            mw._apply(_make_state(tool_calls=call), runtime)
-
-        # 3rd identical call → hash hard_limit=3 fires (not freq)
-        result = mw._apply(_make_state(tool_calls=call), runtime)
-        assert result is not None
-        msg = result["messages"][0]
-        assert isinstance(msg, AIMessage)
-        assert _HARD_STOP_MSG in msg.content
 
 
 class TestEditAwareReset: