drydock-cli 2.7.38__tar.gz → 2.7.39__tar.gz

drydock_cli-2.7.39/.auto_release.lock

@@ -0,0 +1 @@
+2749816

{drydock_cli-2.7.38 → drydock_cli-2.7.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.38
+Version: 2.7.39
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.7.38 → drydock_cli-2.7.39}/drydock/core/agent_loop.py

@@ -693,6 +693,25 @@ class AgentLoop:
         _ar_t1 = time.perf_counter()
         logger.warning("[TIMING] _auto_route_task: %.2fs", _ar_t1 - _ar_t0)
 
+        # === AUTO-PREFETCH RETRIEVE ===
+        # HLE Phase 1 finding (memory: project_graphrag_underused.md): Gemma 4
+        # almost never calls retrieve() on its own for general-knowledge
+        # questions — it defaults to web_search instead. So a curated
+        # GraphRAG corpus is invisible to the model unless we surface it
+        # automatically. This hook runs retrieve(query=user_msg[:300]) and,
+        # if there are real hits (above a quality threshold), prepends them
+        # as a system note BEFORE the first LLM call. Zero behavior change
+        # when the index has nothing relevant; pure lift when it does.
+        #
+        # Env-gated via DRYDOCK_AUTO_RETRIEVE so existing workflows are
+        # unaffected. Set to "1" or "true" to enable.
+        if os.environ.get("DRYDOCK_AUTO_RETRIEVE", "").strip().lower() in ("1", "true", "yes"):
+            logger.warning("[AUTO-RETRIEVE] hook entry, query=%r", (user_msg or "")[:80])
+            try:
+                self._auto_prefetch_retrieve(user_msg)
+            except Exception as _e:
+                logger.warning("auto-prefetch retrieve failed (skipped): %s", _e, exc_info=True)
+
         try:
             should_break_loop = False
             tool_turns = 0
@@ -1885,7 +1904,30 @@ class AgentLoop:
         if len(cleaned) != len(self.messages):
             self.messages.reset(cleaned)
 
-        # Fix 2: If last message is assistant, add a user "Continue." prompt.
+        # Fix 2: Drop empty assistant messages (no content AND no tool_calls).
+        # These violate the OpenAI schema and cause 400 errors on the next LLM
+        # call. They arise when the model returns only thinking/reasoning tokens
+        # (which get stripped) and stall-retry exhaustion leaves the empty msg
+        # in history. An assistant message that follows a tool result must have
+        # either content or tool_calls; if neither, drop it along with any
+        # orphaned tool result messages that precede it (to keep role ordering
+        # valid).
+        cleaned2: list[LLMMessage] = []
+        for msg in self.messages:
+            if (msg.role == Role.assistant
+                    and not (msg.content or "").strip()
+                    and not msg.tool_calls):
+                # Skip empty assistant — also drop any immediately preceding
+                # tool result that would be left dangling without a matching
+                # assistant turn.
+                while cleaned2 and cleaned2[-1].role == Role.tool:
+                    cleaned2.pop()
+            else:
+                cleaned2.append(msg)
+        if len(cleaned2) != len(self.messages):
+            self.messages.reset(cleaned2)
+
+        # Fix 3: If last message is assistant, add a user "Continue." prompt.
         # The auto-Continue exists so Gemma 4 keeps executing multi-step plans
         # without stopping prematurely at an intermediate text response. For
         # stress runs against prompts that don't need tool calls (pure
@@ -2776,6 +2818,133 @@ class AgentLoop:
 
         return None
 
+    def _auto_prefetch_retrieve(self, user_msg: str) -> None:
+        """Auto-fetch relevant chunks from GraphRAG and inject as system note.
+
+        Runs synchronously (the GraphRAG retriever is a fast SQLite query).
+        Caps the query length at 300 chars and the injected context at 2000
+        chars to avoid blowing context budget on long user prompts.
+
+        Quality gate: only inject if at least one text-chunk hit has score
+        >= 8.0 (the indexer's score is roughly TF-IDF magnitude). Below
+        that, the retrieval is probably noise and would just bloat the
+        prompt.
+
+        See memory/project_graphrag_underused.md for why this exists:
+        Gemma 4 doesn't call retrieve() on its own for general-knowledge
+        questions, so a curated index is invisible without a hook like
+        this one.
+        """
+        try:
+            from drydock.graphrag import Index
+            db = os.environ.get("DRYDOCK_GRAPHRAG_DB") or str(
+                Path.home() / ".drydock" / "graphrag.sqlite"
+            )
+            if not Path(db).is_file():
+                logger.warning("[AUTO-RETRIEVE] db missing: %s", db)
+                return
+            idx = Index(db)
+        except Exception as e:
+            logger.warning("[AUTO-RETRIEVE] setup failed: %s", e, exc_info=True)
+            return
+
+        # Extract the actual question from boilerplate. HLE-style prompts
+        # are wrapped: "Answer this question. End your response with...
+        # QUESTION: <real text>". Without this strip the retrieve query
+        # matches scaffolding (CLAUDE.md learnings, etc.) instead of the
+        # actual content. Also strip "FINAL ANSWER:" trailing instructions.
+        raw = (user_msg or "")
+        q_marker = raw.find("QUESTION:")
+        if q_marker >= 0:
+            raw = raw[q_marker + len("QUESTION:"):]
+        # Drop trailing answer-format instructions
+        for stopper in ("FINAL ANSWER:", "Your answer", "Format your", "End your response"):
+            idx_ = raw.find(stopper)
+            if idx_ > 50:  # only strip if there's still meaningful content
+                raw = raw[:idx_]
+        query = raw.strip()[:400]
+        if len(query) < 10:
+            logger.warning("[AUTO-RETRIEVE] query too short (%d chars)", len(query))
+            return
+        logger.warning("[AUTO-RETRIEVE] extracted query: %r", query[:120])
+
+        try:
+            result = idx.retrieve(query, symbol_limit=0, text_limit=4)
+        except Exception as e:
+            logger.warning("[AUTO-RETRIEVE] query failed: %s", e, exc_info=True)
+            return
+
+        text_hits = getattr(result, "text", None) or getattr(result, "text_hits", []) or []
+        QUALITY_THRESHOLD = 8.0
+        good_hits = [h for h in text_hits if getattr(h, "score", 0) >= QUALITY_THRESHOLD]
+        logger.warning("[AUTO-RETRIEVE] %d total hits, %d above threshold %.1f",
+                       len(text_hits), len(good_hits), QUALITY_THRESHOLD)
+        if not good_hits:
+            return
+
+        # Build the system note. Cap at ~2000 chars total.
+        chunks = []
+        budget = 2000
+        for h in good_hits[:3]:
+            text = (getattr(h, "content", "") or "").strip()
+            score = float(getattr(h, "score", 0))
+            file_ = getattr(h, "file", "") or "?"
+            s, e = getattr(h, "start_line", 0), getattr(h, "end_line", 0)
+            piece = f"--- {file_}:{s}-{e} (score={score:.1f}) ---\n{text}"
+            if len(piece) > budget:
+                piece = piece[:budget] + "..."
+            chunks.append(piece)
+            budget -= len(piece) + 4
+            if budget <= 0:
+                break
+
+        # SYNTHETIC TOOL CALL: instead of mutating the user message
+        # (which iter6-9 proved is treated as scaffolding by Gemma 4 — it
+        # ignores inline references and trusts its training prior), spawn
+        # a fake assistant->tool message pair that LOOKS like the model
+        # called retrieve() and got results. Models trust tool outputs
+        # as authoritative input.
+        #
+        # Sequence:
+        #   user -> [our synthetic assistant with tool_call retrieve]
+        #        -> [our synthetic tool result with the chunks]
+        #        -> real LLM turn begins from there
+        from drydock.core.types import ToolCall, FunctionCall as _FC
+        import uuid
+
+        tool_call_id = f"auto-retrieve-{uuid.uuid4().hex[:16]}"
+        tool_args = json.dumps({"query": (user_msg or "")[:200]})
+        synth_assistant = LLMMessage(
+            role=Role.assistant,
+            content="",
+            tool_calls=[
+                ToolCall(
+                    id=tool_call_id,
+                    function=_FC(name="retrieve", arguments=tool_args),
+                    type="function",
+                )
+            ],
+        )
+        # Format chunks as the retrieve tool's actual output shape.
+        formatted = "=== TEXT ===\n\n" + "\n\n".join(chunks)
+        synth_tool = LLMMessage(
+            role=Role.tool,
+            content=formatted,
+            name="retrieve",
+            tool_call_id=tool_call_id,
+        )
+        self.messages.append(synth_assistant)
+        self.messages.append(synth_tool)
+
+        logger.warning(
+            "[AUTO-RETRIEVE] synthesized retrieve tool result: %d chunks "
+            "(top score %.1f, content %d chars), msgs now %d",
+            len(chunks),
+            max(float(getattr(h, "score", 0)) for h in good_hits),
+            len(formatted),
+            len(self.messages),
+        )
+
     async def _auto_route_task(self, user_msg: str) -> None:
         """Lightweight auto-context: list project files and key docs.
 

{drydock_cli-2.7.38 → drydock_cli-2.7.39}/drydock/core/steering_hook.py

@@ -52,7 +52,9 @@ def _initialize() -> _CachedSteering | None:
 
     try:
         from drydock.steering import (
+            LogitBiasSteeringApplier,
             LogOnlySteeringApplier,
+            NullSteeringApplier,
             SteeringConfig,
             load_registry,
         )
@@ -63,13 +65,23 @@ def _initialize() -> _CachedSteering | None:
     root = os.environ.get("DRYDOCK_STEERING_ROOT") or None
     registry = load_registry(root)
     config = SteeringConfig.from_mode_names(mode_names)
-    # Default applier is log-only — a real applier (vLLM sidecar etc.)
-    # is the next-phase deliverable. The seam is the same either way.
-    applier = LogOnlySteeringApplier()
+    # Applier selection via DRYDOCK_STEERING_APPLIER:
+    #   "log_only" (default)  : log-only, no inference change
+    #   "logit_bias"          : token-level steering via vLLM logit_bias
+    #                            (manifest must carry tags.tokens_boost
+    #                            and/or tags.tokens_suppress)
+    #   "null"                : no-op (same as not setting MODES at all)
+    # Real activation steering (VllmSidecarSteeringApplier) lands later.
+    kind = os.environ.get("DRYDOCK_STEERING_APPLIER", "log_only").strip().lower()
+    if kind == "logit_bias":
+        applier = LogitBiasSteeringApplier()
+    elif kind == "null":
+        applier = NullSteeringApplier()
+    else:
+        applier = LogOnlySteeringApplier()
     logger.info(
-        "steering: enabled, modes=%s, registry=%s",
-        mode_names,
-        registry.root,
+        "steering: enabled, modes=%s, applier=%s, registry=%s",
+        mode_names, applier.kind, registry.root,
     )
     return _CachedSteering(config=config, registry=registry, applier=applier)
 

{drydock_cli-2.7.38 → drydock_cli-2.7.39}/drydock/core/tools/builtins/bash.py

@@ -586,6 +586,10 @@ class Bash(
             state = self.state.__dict__.setdefault("_bash_history", {})
             # Track total error-exit calls per command (regardless of output).
             err_state = self.state.__dict__.setdefault("_bash_err_count", {})
+            # Track total run count per exact command regardless of output or
+            # exit code.  Catches benchmark/timeit loops where output varies
+            # each run (timings differ) so the hash check never fires.
+            run_count_state = self.state.__dict__.setdefault("_bash_run_count", {})
             # Track consecutive empty-stdout search commands (any command, not
             # just identical ones).  The model semantic-loops by trying different
             # search terms for a non-existent target:
@@ -595,6 +599,73 @@ class Bash(
             _consec_empty_search_state = self.state.__dict__.setdefault(
                 "_consec_empty_searches", {"count": 0}
             )
+            # python -c / python3 -c SyntaxError loop-breaker.
+            # The model truncates multi-line inline scripts; each re-run
+            # produces a SyntaxError but with slightly different stderr
+            # (different column/line), so the hash check never fires.
+            # Track cross-command: any python3 -c that hits SyntaxError.
+            _python_c_err_state = self.state.__dict__.setdefault(
+                "_python_c_syntaxerr_count", 0
+            )
+            _is_python_c_syntaxerr = (
+                returncode != 0
+                and "SyntaxError" in stderr_raw
+                and bool(__import__("re").search(r"\bpython3?\s+-c\b", args.command))
+            )
+            if _is_python_c_syntaxerr:
+                self.state.__dict__["_python_c_syntaxerr_count"] = _python_c_err_state + 1
+                if _python_c_err_state >= 1:
+                    _cnt = _python_c_err_state + 1
+                    yield self._build_result(
+                        command=args.command,
+                        stdout=(
+                            f"[LOOP-BREAKER: `python3 -c '...'` has hit SyntaxError "
+                            f"{_cnt} times. Inline -c scripts get truncated by the "
+                            f"shell when they contain newlines or quotes. "
+                            f"Write the script to a file first, then run it:\n"
+                            f"  write_file path='/tmp/script.py' content='...'\n"
+                            f"  bash command='python3 /tmp/script.py'\n"
+                            f"Do NOT retry the inline -c form again.]"
+                        ),
+                        stderr="",
+                        returncode=returncode,
+                    )
+                    return
+
+            # Exact-command repetition loop-breaker: fires when the same
+            # command text is run 5+ times regardless of output or exit code.
+            # Catches benchmark/timeit/import-check loops where each run has
+            # varying output (timings, object ids) that defeats the hash check.
+            # Excludes commands that write files (heredoc, redirect, sed -i)
+            # since those legitimately run the same form multiple times.
+            _is_write_cmd = bool(
+                __import__("re").search(
+                    r"(>|>>|\bsed\s+-i\b|\btee\b|\bcat\s+<<|\bprintf\b.*>)",
+                    args.command,
+                )
+            )
+            if not _is_write_cmd:
+                _run_cnt = run_count_state.get(args.command, 0) + 1
+                run_count_state[args.command] = _run_cnt
+                if _run_cnt >= 5:
+                    cmd_preview = args.command[:80]
+                    yield self._build_result(
+                        command=args.command,
+                        stdout=(
+                            f"[LOOP-BREAKER: `{cmd_preview}` has been run "
+                            f"{_run_cnt} times this session with the same "
+                            f"command text. The output is stable — re-running "
+                            f"it will not produce new information. "
+                            f"Stop repeating this command and move on to the "
+                            f"next task step. If you are benchmarking, one "
+                            f"run is enough. If you are checking an import, "
+                            f"the result is already known.]\n{stdout}"
+                        ),
+                        stderr=stderr,
+                        returncode=returncode,
+                    )
+                    return
+
             if returncode != 0:
                 err_count = err_state.get(args.command, 0) + 1
                 err_state[args.command] = err_count

{drydock_cli-2.7.38 → drydock_cli-2.7.39}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.7.38"
+version = "2.7.39"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"

{drydock_cli-2.7.38 → drydock_cli-2.7.39}/tests/test_issue_fixes.py

@@ -1,4 +1,4 @@
-"""Regression tests for GitHub issues #4, #5, #6."""
+"""Regression tests for GitHub issues #4, #5, #6, #14."""
 from __future__ import annotations
 
 import os
@@ -116,3 +116,103 @@ class TestIssue6BashAllowlistBasename:
         # Returns None (caller prompts for approval) — not ALWAYS.
         from drydock.core.tools.base import ToolPermission
         assert res != ToolPermission.ALWAYS
+
+
+# Issue #14: empty assistant messages (no content, no tool_calls) persist in
+# history after stall-retry exhaustion and cause 400 errors on the next turn.
+# _sanitize_message_ordering must drop them before the next LLM call.
+
+class TestIssue14EmptyAssistantDropped:
+    def _make_minimal_agent(self):
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import MessageList
+        al = object.__new__(AgentLoop)
+        al.messages = MessageList()
+        # stubs for methods called by _sanitize_message_ordering
+        al._truncate_old_tool_results = lambda: None
+        al._proactive_prune_write_oscillation = lambda: None
+        import os as _os
+        al._os = _os
+        return al
+
+    def test_empty_assistant_dropped(self):
+        """Empty assistant message (no content, no tool_calls) is dropped."""
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import LLMMessage, Role, MessageList
+        import os
+        al = object.__new__(AgentLoop)
+        al.messages = MessageList()
+        al._truncate_old_tool_results = lambda: None
+        al._proactive_prune_write_oscillation = lambda: None
+
+        al.messages.append(LLMMessage(role=Role.user, content="hello"))
+        al.messages.append(LLMMessage(role=Role.assistant, content=None))  # empty — bug
+
+        original_env = os.environ.get("DRYDOCK_AUTO_CONTINUE_DISABLE")
+        os.environ["DRYDOCK_AUTO_CONTINUE_DISABLE"] = "1"
+        try:
+            al._sanitize_message_ordering()
+        finally:
+            if original_env is None:
+                os.environ.pop("DRYDOCK_AUTO_CONTINUE_DISABLE", None)
+            else:
+                os.environ["DRYDOCK_AUTO_CONTINUE_DISABLE"] = original_env
+
+        roles = [m.role for m in al.messages]
+        assert Role.assistant not in roles, f"Empty assistant must be dropped; got {roles}"
+
+    def test_empty_assistant_with_preceding_tool_result_both_dropped(self):
+        """Tool result immediately before an empty assistant is also dropped
+        to avoid a dangling tool message with no matching assistant turn."""
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import LLMMessage, Role, MessageList, ToolCall, FunctionCall
+        import os
+        al = object.__new__(AgentLoop)
+        al.messages = MessageList()
+        al._truncate_old_tool_results = lambda: None
+        al._proactive_prune_write_oscillation = lambda: None
+
+        al.messages.append(LLMMessage(role=Role.user, content="do it"))
+        al.messages.append(LLMMessage(
+            role=Role.assistant,
+            content=None,
+            tool_calls=[ToolCall(id="c1", function=FunctionCall(name="bash", arguments="{}"))],
+        ))
+        al.messages.append(LLMMessage(role=Role.tool, content="ok", tool_call_id="c1"))
+        al.messages.append(LLMMessage(role=Role.assistant, content=None))  # empty — bug
+
+        os.environ["DRYDOCK_AUTO_CONTINUE_DISABLE"] = "1"
+        try:
+            al._sanitize_message_ordering()
+        finally:
+            os.environ.pop("DRYDOCK_AUTO_CONTINUE_DISABLE", None)
+
+        roles = [m.role for m in al.messages]
+        # The empty assistant AND its preceding orphan tool result should be gone
+        assert roles == [Role.user, Role.assistant, Role.tool] or roles == [Role.user], \
+            f"Unexpected roles after sanitize: {roles}"
+        # The productive assistant (with tool_calls) must survive
+        productive = [m for m in al.messages if m.role == Role.assistant]
+        assert all(m.tool_calls for m in productive), "Non-empty assistant must keep tool_calls"
+
+    def test_non_empty_assistant_preserved(self):
+        """Assistant messages with content are never dropped."""
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import LLMMessage, Role, MessageList
+        import os
+        al = object.__new__(AgentLoop)
+        al.messages = MessageList()
+        al._truncate_old_tool_results = lambda: None
+        al._proactive_prune_write_oscillation = lambda: None
+
+        al.messages.append(LLMMessage(role=Role.user, content="hi"))
+        al.messages.append(LLMMessage(role=Role.assistant, content="I'm here"))
+
+        os.environ["DRYDOCK_AUTO_CONTINUE_DISABLE"] = "1"
+        try:
+            al._sanitize_message_ordering()
+        finally:
+            os.environ.pop("DRYDOCK_AUTO_CONTINUE_DISABLE", None)
+
+        roles = [m.role for m in al.messages]
+        assert Role.assistant in roles, "Non-empty assistant must not be dropped"

drydock_cli-2.7.39/tests/tools/test_bash_exact_cmd_loop_breaker.py

@@ -0,0 +1,59 @@
+"""Regression tests for the exact-command repetition loop-breaker.
+
+The model sometimes reruns the same bash command 5+ times (timeit benchmarks,
+import-check one-liners, etc.) even though each run's output varies slightly
+(different timing, different object id).  The hash-based dedup never fires
+because hashes differ.  This loop-breaker fires on the 5th identical run
+regardless of output content.
+"""
+from __future__ import annotations
+
+import pytest
+
+from tests.mock.utils import collect_result
+from drydock.core.tools.base import BaseToolState
+from drydock.core.tools.builtins.bash import Bash, BashArgs, BashToolConfig
+
+
+@pytest.fixture
+def bash(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    config = BashToolConfig()
+    return Bash(config=config, state=BaseToolState())
+
+
+@pytest.mark.asyncio
+async def test_four_runs_no_breaker(bash, tmp_path):
+    """Running the same command 4 times does not trigger the loop-breaker."""
+    cmd = "echo hello_unique_test_marker"
+    for _ in range(4):
+        result = await collect_result(bash.run(BashArgs(command=cmd)))
+    assert "LOOP-BREAKER" not in result.stdout
+
+
+@pytest.mark.asyncio
+async def test_fifth_run_triggers_loop_breaker(bash, tmp_path):
+    """5th run of the same exact command triggers the loop-breaker."""
+    cmd = "echo identical_cmd_loop_test"
+    for _ in range(5):
+        result = await collect_result(bash.run(BashArgs(command=cmd)))
+    assert "LOOP-BREAKER" in result.stdout
+    assert "5" in result.stdout
+
+
+@pytest.mark.asyncio
+async def test_write_command_exempt(bash, tmp_path):
+    """Commands that write files (> redirect) are exempt from the counter."""
+    outfile = tmp_path / "out.txt"
+    cmd = f"echo data > {outfile}"
+    for _ in range(5):
+        result = await collect_result(bash.run(BashArgs(command=cmd)))
+    assert "LOOP-BREAKER" not in result.stdout
+
+
+@pytest.mark.asyncio
+async def test_distinct_commands_no_breaker(bash, tmp_path):
+    """Different commands don't share the run counter."""
+    for i in range(6):
+        result = await collect_result(bash.run(BashArgs(command=f"echo cmd_{i}")))
+    assert "LOOP-BREAKER" not in result.stdout

drydock_cli-2.7.39/tests/tools/test_bash_python_c_syntaxerr_loop_breaker.py

@@ -0,0 +1,57 @@
+"""Regression tests for the python3 -c SyntaxError loop-breaker.
+
+The model often truncates multi-line inline scripts, gets a SyntaxError,
+and retries with slightly different content.  Because each stderr differs
+(different column/line), the hash-based dedup never fires.  The dedicated
+cross-command counter catches this on the 2nd failure and redirects to
+write_file.
+"""
+from __future__ import annotations
+
+import pytest
+
+from tests.mock.utils import collect_result
+from drydock.core.tools.base import BaseToolState
+from drydock.core.tools.builtins.bash import Bash, BashArgs, BashToolConfig
+
+
+@pytest.fixture
+def bash(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    config = BashToolConfig()
+    return Bash(config=config, state=BaseToolState())
+
+
+@pytest.mark.asyncio
+async def test_first_syntaxerr_passes_through(bash):
+    """First python3 -c SyntaxError is returned normally (no loop-breaker yet)."""
+    result = await collect_result(bash.run(BashArgs(command="python3 -c \"print('hello\"")))
+    assert "LOOP-BREAKER" not in result.stdout
+
+
+@pytest.mark.asyncio
+async def test_second_syntaxerr_triggers_loop_breaker(bash):
+    """Second python3 -c SyntaxError (different command) triggers the loop-breaker."""
+    # Truncated strings produce SyntaxError (unterminated string literal)
+    await collect_result(bash.run(BashArgs(command="python3 -c \"x = {'key': 'val\"")))
+    result = await collect_result(bash.run(BashArgs(command="python3 -c \"y = {'k2': 'v2\"")))
+    assert "LOOP-BREAKER" in result.stdout
+    assert "write_file" in result.stdout.lower() or "Write the script" in result.stdout
+
+
+@pytest.mark.asyncio
+async def test_loop_breaker_only_fires_on_syntaxerr(bash):
+    """ImportError (no SyntaxError) does not increment the python3 -c counter."""
+    # ImportError — not a SyntaxError; shouldn't accumulate in the counter
+    cmd = "python3 -c \"import nonexistent_pkg_xyz_abc\""
+    await collect_result(bash.run(BashArgs(command=cmd)))
+    result = await collect_result(bash.run(BashArgs(command=cmd)))
+    assert "LOOP-BREAKER" not in result.stdout or "python3 -c" not in result.stdout
+
+
+@pytest.mark.asyncio
+async def test_successful_python_c_does_not_accumulate(bash):
+    """Successful python3 -c runs don't trigger the breaker."""
+    await collect_result(bash.run(BashArgs(command="python3 -c \"print(1+1)\"")))
+    result = await collect_result(bash.run(BashArgs(command="python3 -c \"print(2+2)\"")))
+    assert "LOOP-BREAKER" not in result.stdout