feat: add identical-tool-call stuck-loop backstop independent of errors

The existing max_consecutive_failures backstop only trips when every
tool call in a batch reports is_error=True, so it can't catch a
degenerate loop where a tool falsely reports success on a call that
never made progress (observed: a stuck agent burning 15 minutes and
142k tokens of context with no backstop firing).

Add max_consecutive_identical_calls (default 10), tracked from the
toolset's own identical-argument repeat streak rather than each call's
reported success/failure, as a second independent backstop.

Author: elkaix

CHANGELOG.md

@@ -15,6 +15,19 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+- Cap context-compaction summary output length so a slow/degenerate local
+  model completion (observed hanging the soul loop indefinitely on local
+  OpenAI-compatible backends) can no longer run unbounded.
+- Send Qwen3.x's binary `enable_thinking` chat-template toggle instead of a
+  tiered `reasoning_effort` value on self-hosted openai_legacy endpoints
+  (llama.cpp/vLLM/LM Studio), where the model only supports on/off and was
+  silently promoting every configured effort level to full reasoning.
+- Add a second, independent stuck-loop backstop (`max_consecutive_identical_calls`,
+  default 10) that stops a turn after enough consecutive tool calls with identical
+  arguments, regardless of whether each call reports success — the existing
+  all-error backstop can't catch a loop where a tool falsely reports success on a
+  call that never made progress.
+
 ## 0.54.0 (2026-06-30)
 
 - **New `Workflow` tool for deterministic multi-agent orchestration.** The default

src/pythinker_code/config.py

@@ -586,6 +586,11 @@ class LoopControl(BaseModel):
     call failed (a degenerate stuck loop), instead of continuing to
     ``max_steps_per_turn``. The turn ends with a ``stuck`` outcome and a handoff
     summary of what was tried. ``0`` disables the backstop. Default: 8."""
+    max_consecutive_identical_calls: int = Field(default=10, ge=0)
+    """Yield to the user after this many consecutive tool calls with identical
+    arguments, even if each call reports success. Tracked independently of
+    ``max_consecutive_failures`` so a tool that falsely reports success on a call
+    that made no progress can't defeat the backstop. ``0`` disables it. Default: 10."""
     max_truncation_recoveries: int = Field(default=3, ge=0)
     """When a model response is cut off by the output-token limit and makes no tool call,
     nudge the model to continue at most this many times per turn before surfacing the

src/pythinker_code/soul/pythinkersoul.py

@@ -388,12 +388,17 @@ def _should_nudge_truncation(
 
 
 def _stuck_summary_message(
-    failures: int, tool_calls: Sequence[ToolCall], tool_results: Sequence[ToolResult]
+    count: int,
+    tool_calls: Sequence[ToolCall],
+    tool_results: Sequence[ToolResult],
+    *,
+    reason: str = "steps each had every tool call fail",
 ) -> Message:
     """Build a concise handoff message when the loop yields on a degenerate stuck loop.
 
-    Surfaces a count of consecutive all-error steps and a brief of what the last
-    step tried, so the human can take over without reconstructing state.
+    Surfaces a count (consecutive all-error steps, or consecutive identical calls,
+    per ``reason``) and a brief of what the last step tried, so the human can take
+    over without reconstructing state.
     """
     calls_by_id = {call.id: call for call in tool_calls}
     tried: list[str] = []
@@ -409,8 +414,8 @@ def _stuck_summary_message(
             brief = brief[:200] + "…"
         tried.append(f"- {name}: {brief}")
     text = (
-        f"I appear to be stuck — the last {failures} steps each had every tool call "
-        "fail, so I'm stopping and handing control back to you rather than continuing.\n\n"
+        f"I appear to be stuck — the last {count} {reason}, so I'm stopping and "
+        "handing control back to you rather than continuing.\n\n"
         "What I last tried:\n" + "\n".join(tried) + "\n\n"
         "You can adjust the request, fix the underlying issue, or tell me how to proceed."
     )
@@ -2197,6 +2202,32 @@ async def _pythinker_core_step_with_retry() -> StepResult:
                     return StepOutcome(stop_reason="stuck", assistant_message=summary)
             else:
                 self._consecutive_failures = 0
+
+            # Second, independent backstop: the same tool call repeated with
+            # identical arguments enough times in a row, regardless of whether
+            # each call reports success — catches a tool that falsely reports
+            # success on a call that never made progress, which the all-error
+            # check above can't see.
+            repeat_threshold = self._loop_control.max_consecutive_identical_calls
+            if repeat_threshold and isinstance(self._agent.toolset, PythinkerToolset):
+                repeat_count = self._agent.toolset.consecutive_repeat_count
+                if repeat_count >= repeat_threshold:
+                    from pythinker_code.telemetry import track
+
+                    summary = _stuck_summary_message(
+                        repeat_count,
+                        result.tool_calls,
+                        results,
+                        reason="tool calls were identical",
+                    )
+                    await self._context.append_message(summary)
+                    wire_send(TextPart(text=summary.extract_text(" ")))
+                    track(
+                        "agent_stuck_repeat",
+                        consecutive_repeat_calls=repeat_count,
+                        model=self._runtime.llm.model_name,
+                    )
+                    return StepOutcome(stop_reason="stuck", assistant_message=summary)
             return None
 
         # A tool-call-free message normally ends the turn. If it is only a

src/pythinker_code/soul/toolset.py

@@ -818,6 +818,16 @@ def dedup_triggered(self) -> bool:
         """Whether a cross-step duplicate was blocked in the current step."""
         return self._dedup_triggered
 
+    @property
+    def consecutive_repeat_count(self) -> int:
+        """Length of the current streak of identical-argument tool calls.
+
+        Tracked independently of each call's reported success/failure, so it
+        still catches a degenerate loop even if a tool falsely reports success
+        on a call that made no progress.
+        """
+        return self._consecutive_count
+
     def handle(self, tool_call: ToolCall) -> HandleResult:
         token = current_tool_call.set(tool_call)
         try:

tests/core/test_config.py

@@ -50,6 +50,7 @@ def test_default_config_dump():
             "loop_control": {
                 "max_steps_per_turn": 1000,
                 "max_consecutive_failures": 8,
+                "max_consecutive_identical_calls": 10,
                 "max_truncation_recoveries": 3,
                 "max_compaction_failures": 1,
                 "max_session_cost_usd": None,

tests/core/test_pythinkersoul_stuck_loop.py

@@ -26,6 +26,7 @@
 from pythinker_code.soul.agent import Agent, BuiltinSystemPromptArgs, Runtime
 from pythinker_code.soul.context import Context
 from pythinker_code.soul.pythinkersoul import PythinkerSoul, TurnStopReason
+from pythinker_code.soul.toolset import PythinkerToolset
 from pythinker_code.utils.aioqueue import QueueShutDown
 from pythinker_code.wire import Wire
 
@@ -159,6 +160,43 @@ def _make_soul(
     return context, soul
 
 
+def _make_soul_with_pythinker_toolset(
+    runtime: Runtime, provider: _ScriptedToolCallProvider, tmp_path: Path
+) -> tuple[Context, PythinkerSoul]:
+    """Like `_make_soul`, but with a real `PythinkerToolset` — required to exercise the
+    identical-call repeat backstop, which is tracked on `PythinkerToolset` specifically."""
+    llm = LLM(chat_provider=provider, max_context_size=100_000, capabilities=set())
+    runtime = Runtime(
+        config=runtime.config,
+        llm=llm,
+        session=runtime.session,
+        builtin_args=runtime.builtin_args,
+        denwa_renji=runtime.denwa_renji,
+        approval=runtime.approval,
+        labor_market=runtime.labor_market,
+        environment=runtime.environment,
+        notifications=runtime.notifications,
+        background_tasks=runtime.background_tasks,
+        skills=runtime.skills,
+        oauth=runtime.oauth,
+        additional_dirs=runtime.additional_dirs,
+        skills_dirs=runtime.skills_dirs,
+        role=runtime.role,
+    )
+    toolset = PythinkerToolset()
+    toolset.add(_BoomTool())
+    toolset.add(_OkTool())
+    agent = Agent(
+        name="Stuck Test Agent",
+        system_prompt="Stuck test prompt.",
+        toolset=toolset,
+        runtime=runtime,
+    )
+    context = Context(file_backend=tmp_path / "history.jsonl")
+    soul = PythinkerSoul(agent, context=context)
+    return context, soul
+
+
 async def _drain_ui_messages(wire: Wire) -> None:
     wire_ui = wire.ui_side(merge=True)
     while True:
@@ -506,6 +544,44 @@ async def test_max_consecutive_failures_zero_disables_backstop(
     assert record_turn.call_args.kwargs["stop_reason"] == "no_tool_calls"
 
 
+@pytest.mark.asyncio
+async def test_consecutive_identical_calls_yield_stuck_outcome(
+    runtime: Runtime, tmp_path: Path
+) -> None:
+    """N consecutive identical-argument tool calls stop the turn with `stuck`, even
+    though every call reports success — this backstop is independent of the
+    all-error check above, so it still catches a tool that falsely reports success
+    on a call that made no progress."""
+    runtime.config.loop_control.max_consecutive_identical_calls = 3
+    runtime.config.loop_control.max_steps_per_turn = 50
+    provider = _ScriptedToolCallProvider(["Ok"] * 10)
+    context, soul = _make_soul_with_pythinker_toolset(runtime, provider, tmp_path)
+
+    with patch("pythinker_code.telemetry.metrics.record_turn") as record_turn:
+        await run_soul(soul, "go", _drain_ui_messages, asyncio.Event())
+
+    assert provider.generate_attempts == 3
+    assert record_turn.call_args.kwargs["stop_reason"] == "stuck"
+    assert "identical" in context.history[-1].extract_text(" ").lower()
+
+
+@pytest.mark.asyncio
+async def test_max_consecutive_identical_calls_zero_disables_backstop(
+    runtime: Runtime, tmp_path: Path
+) -> None:
+    """A threshold of 0 disables the identical-call backstop entirely."""
+    runtime.config.loop_control.max_consecutive_identical_calls = 0
+    runtime.config.loop_control.max_steps_per_turn = 50
+    provider = _ScriptedToolCallProvider(["Ok", "Ok", "Ok", "Ok", None])
+    context, soul = _make_soul_with_pythinker_toolset(runtime, provider, tmp_path)
+
+    with patch("pythinker_code.telemetry.metrics.record_turn") as record_turn:
+        await run_soul(soul, "go", _drain_ui_messages, asyncio.Event())
+
+    assert provider.generate_attempts == 5
+    assert record_turn.call_args.kwargs["stop_reason"] == "no_tool_calls"
+
+
 @pytest.mark.asyncio
 async def test_truncated_response_nudges_continuation(runtime: Runtime, tmp_path: Path) -> None:
     """A response cut off by the output-token limit (no tool calls) nudges the model to