[argus] loop_detector + prompt: nudge toward observation when stuck

Two related changes addressing a failure mode observed on Qwen3-27B:
the model has full multimodal vision but tends to skip past observing
tool output and pattern-match the bug from priors. When iteration
doesn't change the visible result, a single-line "stop calling tools"
warning amplifies the wrong instinct — the model concludes "I should
do this all at once" and rewrites the file from scratch, usually
introducing new bugs.

1. loop_detection_middleware: rewrite the soft-warning text.

   Old: "[LOOP DETECTED] You are repeating the same tool calls. Stop
        calling tools and produce your final answer now."

   New: "[REPEAT TOOL CALL DETECTED] You have just made the same tool
        call several times in a row. If the observable result is not
        changing between calls, your model of the bug is likely
        wrong... (a) describe what you actually observe in the latest
        result, (b) note explicitly what is different from what you
        expected, (c) instrument or pick a clearly different angle.
        Do not 'rewrite from scratch' as a debugging strategy."

   Hard-stop messages (>= hard_limit) are unchanged — at that point
   producing a final answer is the right outcome. Soft-warning
   threshold is the place where a strategy switch helps, so the new
   text points at strategy not at termination.

   Test assertions updated from "LOOP DETECTED" to
   "REPEAT TOOL CALL DETECTED" — 8 sites in
   test_loop_detection_middleware.py.

2. lead_agent prompt: add an "Observe before you diagnose" paragraph
   to <debugging_when_stuck>.

   Tells the model to describe what it actually sees in tool output
   (visible elements, missing elements, error messages and warnings
   verbatim) BEFORE proposing a fix. This forces the next fix to be
   grounded in observation rather than priors, breaking the
   pattern-match-from-prior loop that produces consecutive same-area
   blind fixes.

   Companion to a render-and-verify SKILL.md update on the Argus side
   that turns this into an explicit numbered flow.

PR-candidate: maybe (loop detector text), maybe (prompt block)
Reason: Both changes target a Qwen-shaped failure mode that we observed
        on a specific minion-render thread; the principles generalise
        but upstream may have different priors on what soft-warning
        text should say.

Author: Nichol4s

backend/packages/harness/deerflow/agents/lead_agent/prompt.py

@@ -464,6 +464,10 @@ def _build_subagent_section(max_concurrent: int) -> str:
 **For deliverables in `/mnt/user-data/outputs`:** write the file once with `write_file`. If you find a bug after writing, use `str_replace` to fix in place. Do not re-run a HEREDOC `cat > ...` to rewrite the whole file.
 </file_editing>
 <debugging_when_stuck>
+**Observe before you diagnose.** When a tool returns output (rendered screenshot, test results, log dump, command stdout), describe what you actually see in plain words *before* proposing a fix.
+List visible elements, missing elements, error messages, and warnings — verbatim, not paraphrased. State explicitly what differs from your expectation.
+This forces you to ground the next fix in observation rather than priors. The cost is one short paragraph; the benefit is that you stop pattern-matching bugs that aren't there.
+
 **Two failed fixes in a row that don't change the observable result is a signal — your model of the bug is wrong.**
 A third blind fix is the most expensive thing you can do: it costs tokens, takes time, and probably won't work either. Stop fixing and start instrumenting.
 

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

@@ -126,10 +126,21 @@ def _hash_tool_calls(tool_calls: list[dict]) -> str:
     return hashlib.md5(blob.encode()).hexdigest()[:12]
 
 
-_WARNING_MSG = "[LOOP DETECTED] You are repeating the same tool calls. Stop calling tools and produce your final answer now. If you cannot complete the task, summarize what you accomplished so far."
+_WARNING_MSG = (
+    "[REPEAT TOOL CALL DETECTED] You have just made the same tool call (or near-identical: same tool, similar arguments) several times in a row. "
+    "If the observable result is not changing between calls, your model of the bug is likely wrong — making another similar call is unlikely to help. "
+    "Before the next tool call: (a) describe what you actually observe in the latest result, (b) note explicitly what is different from what you expected, "
+    "(c) instrument (add logging, inspect intermediate values, reduce the test surface) or pick a clearly different angle. "
+    "Do not 'rewrite from scratch' as a debugging strategy — that hides the bug rather than finding it. "
+    "If the task genuinely cannot be completed, summarize what you accomplished and stop."
+)
 
 _TOOL_FREQ_WARNING_MSG = (
-    "[LOOP DETECTED] You have called {tool_name} {count} times without producing a final answer. Stop calling tools and produce your final answer now. If you cannot complete the task, summarize what you accomplished so far."
+    "[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."

backend/tests/test_lead_agent_prompt.py

@@ -123,7 +123,8 @@ def test_apply_prompt_template_includes_debugging_when_stuck_block(monkeypatch):
 
     assert "<debugging_when_stuck>" in prompt
     assert "</debugging_when_stuck>" in prompt
-    # Three core principles must all be present
+    # Four core principles must all be present
+    assert "Observe before you diagnose" in prompt
     assert "Two failed fixes in a row" in prompt
     assert "Instrument first, fix second" in prompt
     assert "reduce the test surface" in prompt

backend/tests/test_loop_detection_middleware.py

@@ -200,7 +200,7 @@ def test_warn_at_threshold(self):
         msgs = result["messages"]
         assert len(msgs) == 1
         assert isinstance(msgs[0], HumanMessage)
-        assert "LOOP DETECTED" in msgs[0].content
+        assert "REPEAT TOOL CALL DETECTED" in msgs[0].content
 
     def test_warn_only_injected_once(self):
         """Warning for the same hash should only be injected once per thread."""
@@ -215,7 +215,7 @@ def test_warn_only_injected_once(self):
         # Third — warning injected
         result = mw._apply(_make_state(tool_calls=call), runtime)
         assert result is not None
-        assert "LOOP DETECTED" in result["messages"][0].content
+        assert "REPEAT TOOL CALL DETECTED" in result["messages"][0].content
 
         # Fourth — warning already injected, should return None
         result = mw._apply(_make_state(tool_calls=call), runtime)
@@ -306,12 +306,12 @@ def test_thread_id_from_runtime_context(self):
         # Second call on thread A — triggers warning (2 >= warn_threshold)
         result = mw._apply(_make_state(tool_calls=call), runtime_a)
         assert result is not None
-        assert "LOOP DETECTED" in result["messages"][0].content
+        assert "REPEAT TOOL CALL DETECTED" in result["messages"][0].content
 
         # Second call on thread B — also triggers (independent tracking)
         result = mw._apply(_make_state(tool_calls=call), runtime_b)
         assert result is not None
-        assert "LOOP DETECTED" in result["messages"][0].content
+        assert "REPEAT TOOL CALL DETECTED" in result["messages"][0].content
 
     def test_lru_eviction(self):
         """Old threads should be evicted when max_tracked_threads is exceeded."""
@@ -533,7 +533,7 @@ def test_freq_warn_at_threshold(self):
         msg = result["messages"][0]
         assert isinstance(msg, HumanMessage)
         assert "read_file" in msg.content
-        assert "LOOP DETECTED" 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)
@@ -545,7 +545,7 @@ def test_freq_warn_only_injected_once(self):
         # 3rd triggers warning
         result = mw._apply(_make_state(tool_calls=[self._read_call("/file_2.py")]), runtime)
         assert result is not None
-        assert "LOOP DETECTED" in result["messages"][0].content
+        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)
@@ -619,7 +619,7 @@ def test_freq_reset_per_thread_clears_only_target(self):
         # 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 "LOOP DETECTED" in result["messages"][0].content
+        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)
@@ -642,7 +642,7 @@ def test_freq_per_thread_isolation(self):
         # 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 "LOOP DETECTED" in result["messages"][0].content
+        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."""