drydock-cli 2.1.2__tar.gz → 2.2.0__tar.gz

{drydock_cli-2.1.2 → drydock_cli-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.1.2
+Version: 2.2.0
 Summary: Drydock — nautical CLI coding agent
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.1.2 → drydock_cli-2.2.0}/PRD.md

@@ -547,11 +547,48 @@ Evidence: removing this one line improved `task(agent="explore")` usage from 1/5
 - Telegram release notifications
 - `whats_new.md` updated
 
+### Phase 15 (Mar 31): Meta-Harness Framework + SWE-bench Push
+
+**Paper:** "Meta-Harness: End-to-End Optimization of Model Harnesses" (arXiv:2603.28052)
+**Key insight:** Optimize the harness around the model, not the model itself. A harness change gave +18pp on TerminalBench-2.
+
+**What we implemented from Meta-Harness:**
+
+1. **Environment bootstrapping** — Single compound shell command before first LLM call gathers:
+   - Repo structure (`find . -name "*.py" | head -30`)
+   - Python version, test framework
+   - Top-level directories, recent commits
+   - Injected as `[Environment Snapshot]` in the prompt
+   - Eliminates 2-4 wasted exploratory turns
+
+2. **AGENTS.md per SWE-bench task** — Auto-created in each worktree with bug-fix workflow instructions
+
+3. **Additive-only changes** — Paper proved that modifying control flow regresses. Only ADD context before the agent loop. This validates our decision to disable the orchestrator and circuit breaker.
+
+**SWE-bench status:**
+- Baseline (v2.1.3 + AGENTS.md): 4/10 file matches (40%)
+- 50-task eval running with env bootstrapping
+- Previous "39-42% pass rate" was file-match only — actual test pass rate was 0%
+- Target: 68% (devstral-small-2 24B, per Mistral's published results)
+- Mistral achieved 68% with Vibe CLI + Cline harness
+
+**Meta-Harness techniques still to implement:**
+- Double-confirmation before completion (verify checklist)
+- Execution trace logging for systematic failure diagnosis
+- Repo-specific routing (different strategies per SWE-bench repo)
+- Draft-then-verify for patches
+- Contrastive examples for decision boundaries
+
+**Reference:** https://github.com/stanford-iris-lab/meta-harness-tbench2-artifact
+
 ### Lessons Learned (Updated)
 
 1. **One prompt line can block an entire feature.** "Restate the goal" prevented tool calling for months.
-2. **Don't rely on the model to delegate.** Force it structurally (orchestrator) or do it before the model responds.
-3. **Same-process API calls can fail.** httpx from inside DryDock got 404 from vLLM. Use the existing backend connection.
-4. **Test the installed package, not source.** Different Python envs (miniconda3 vs miniforge3) have different behavior.
-5. **Explicit Python paths everywhere.** Cron doesn't inherit PATH. Every script must use the full path.
-6. **The circuit breaker was net negative.** It blocked valid retries more than it prevented loops. Failed-only mode is the right balance.
+2. **AGENTS.md is essential for devstral.** Without per-project instructions file, model loops on ls/bash. Auto-created on first session.
+3. **Additive-only harness changes work best.** Every control flow modification (circuit breaker, orchestrator, nudges) caused regressions. Just inject better context.
+4. **The harness matters as much as the model.** Meta-Harness paper shows 6x performance gap from harness changes alone.
+5. **Environment bootstrapping saves turns.** Pre-gathering repo structure/versions eliminates 2-4 wasted exploration turns.
+6. **Plan→Edit workflow is Mistral's design.** Use plan mode first, then switch to accept-edits. Don't try to do everything in one agent shot.
+7. **Same-process API calls can fail.** httpx from inside DryDock got 404 from vLLM. Use the existing backend connection.
+8. **Test the installed package, not source.** Different Python envs (miniconda3 vs miniforge3) have different behavior.
+9. **Explicit Python paths everywhere.** Cron doesn't inherit PATH. Every script must use the full path.

{drydock_cli-2.1.2 → drydock_cli-2.2.0}/drydock/cli/textual_ui/app.py

@@ -398,7 +398,8 @@ class VibeApp(App):  # noqa: PLR0904
             if not hasattr(self, "_pending_messages"):
                 self._pending_messages: list[str] = []
             self._pending_messages.append(value)
-            self.notify(f"Queued — will process after current task ({len(self._pending_messages)} pending)")
+            preview = value[:60] + "..." if len(value) > 60 else value
+            self.notify(f"Queued: \"{preview}\" ({len(self._pending_messages)} pending)")
             return
 
         if value.startswith("!"):

{drydock_cli-2.1.2 → drydock_cli-2.2.0}/drydock/core/agent_loop.py

@@ -299,7 +299,8 @@ class AgentLoop:
         # Auto-create AGENTS.md if no project instructions exist.
         # devstral needs per-project AGENTS.md to anchor its behavior —
         # without it the model loops on ls/bash instead of using subagents.
-        self._ensure_agents_md()
+        if self.stats.steps <= 1:
+            self._ensure_agents_md()
 
         # Load project state for cross-session context
         try:
@@ -541,11 +542,14 @@ class AgentLoop:
                 except (RuntimeError, AgentLoopLLMResponseError) as e:
                     api_error_count += 1
                     if api_error_count > MAX_API_ERRORS:
+                        # Don't stop — reset and let the user know
+                        import asyncio as _aio
                         yield AssistantEvent(
-                            content=f"\n\n[Too many consecutive API errors ({api_error_count}). Last error: {e}. Stopping.]\n",
-                            stopped_by_middleware=True,
+                            content=f"\n\n[{api_error_count} consecutive API errors. Waiting 10s then retrying. Last error: {str(e)[:200]}]\n",
                         )
-                        return
+                        await _aio.sleep(10)
+                        api_error_count = 0  # Reset — give it another chance
+                        continue
                     # Check if the error is about invalid function/tool name
                     error_str = str(e)
                     if "Function name" in error_str or "function" in error_str.lower() and "must be" in error_str.lower():
@@ -696,11 +700,14 @@ class AgentLoop:
                             "search_replace to edit one. Do NOT run any more bash commands."
                         )
                     elif bash_count >= 10:
-                        yield AssistantEvent(
-                            content="\n\n[STOPPED: 10+ bash commands without creating any files. Use write_file.]\n",
-                            stopped_by_middleware=True,
+                        # Redirect, don't stop — prune bash calls and guide
+                        self._prune_repeated_tool_calls()
+                        self._inject_system_note(
+                            "You have run 10+ bash commands without creating files. "
+                            "Use write_file or search_replace NOW. If you need help, "
+                            "ask the user what to do."
                         )
-                        return
+                        bash_count = 6  # Reset partially so it doesn't re-trigger immediately
 
                 # 3-Strike Rule: search_replace keeps failing
                 if search_replace_failures >= 3:
@@ -817,55 +824,56 @@ class AgentLoop:
                     if nudge_text:
                         self._inject_system_note(nudge_text)
 
-                # Check for repeated tool calls (loop detection)
+                # Check for repeated tool calls (loop guidance — never stops, only redirects)
                 if not should_break_loop:
                     rep = self._check_tool_call_repetition()
                     if rep == "FORCE_STOP":
                         repeat_warnings += 1
-                        logger.warning("Detected infinite loop: same tool call %d+ times (warning %d)", REPEAT_FORCE_STOP_THRESHOLD, repeat_warnings)
-                        if repeat_warnings >= 5:
-                            # Stop after 5 redirects — model is not recovering
-                            yield AssistantEvent(
-                                content="\n\n[Stopping: exhausted all retry attempts.]\n",
-                                stopped_by_middleware=True,
-                            )
-                            return
-                        # Redirect instead of kill — force an edit attempt
-                        self._inject_system_note(
-                            "CRITICAL: You are in an infinite loop. STOP all searching/reading. "
-                            "Based on what you have already seen, use search_replace RIGHT NOW to make "
-                            "your best fix attempt. If you don't know the exact text, use read_file ONE MORE TIME "
-                            "on the specific function, then search_replace immediately.",
-                            replace_last_tool=True,
-                        )
+                        logger.warning("Loop detected: same call %d+ times (redirect %d)", REPEAT_FORCE_STOP_THRESHOLD, repeat_warnings)
+                        # Prune repeated calls and redirect — NEVER stop
                         self._prune_repeated_tool_calls()
+                        if repeat_warnings <= 3:
+                            self._inject_system_note(
+                                "You are repeating the same action. Try a DIFFERENT approach:\n"
+                                "- If searching: pick a different search term or file\n"
+                                "- If testing: read the error and fix the code first\n"
+                                "- If stuck: use task(agent='explore') to get a fresh perspective",
+                                replace_last_tool=True,
+                            )
+                        else:
+                            # After 3+ redirects, ask the user what to do
+                            self._inject_system_note(
+                                "You have been redirected multiple times for repeating actions. "
+                                "Ask the user for clarification on what to do next.",
+                                replace_last_tool=True,
+                            )
                     elif rep and rep.startswith("WARNING"):
-                        # During investigation (no edit yet), soft-count warnings from
-                        # investigation tools — they need room to explore.
                         stuck_tool = ""
                         if "|" in rep:
                             stuck_tool = rep.split("|", 1)[1]
-                        is_investigation_warning = (
-                            not has_made_edit
-                            and stuck_tool in ("grep", "read_file")
-                        )
-                        if is_investigation_warning:
-                            repeat_warnings += 0.3  # Count less — investigation needs room
+                        is_investigation = not has_made_edit and stuck_tool in ("grep", "read_file")
+                        if is_investigation:
+                            repeat_warnings += 0.3
                         else:
                             repeat_warnings += 1
-                        logger.warning("Detected repeated tool calls (warning %.1f, investigation=%s)", repeat_warnings, is_investigation_warning)
-                        if repeat_warnings >= 6:
-                            yield AssistantEvent(
-                                content="\n\n[Stopping: too many repeated actions despite warnings.]\n",
-                                stopped_by_middleware=True,
-                            )
-                            return
+                        logger.warning("Repeated tool calls (warning %.1f, investigation=%s)", repeat_warnings, is_investigation)
 
-                        # On 3rd warning: prune duplicate tool calls from history
-                        # This gives the model a "fresh start" with less repetitive context
-                        if repeat_warnings == 3:
+                        # Prune on 3rd warning
+                        if repeat_warnings >= 3 and int(repeat_warnings) % 3 == 0:
                             self._prune_repeated_tool_calls()
 
+                        # Tool-specific guidance
+                        nudge = ""
+                        if stuck_tool in ("read_file",):
+                            nudge = " You already read this file. Make your edit with search_replace now."
+                        elif stuck_tool in ("grep",):
+                            nudge = " Try a different search term, or read the file you found."
+                        elif stuck_tool in ("bash", "run_command"):
+                            nudge = " Read the error output and fix the code with search_replace."
+                        self._inject_system_note(
+                            f"You are repeating the same tool call.{nudge} Try something different."
+                        )
+
                         # Extract tool-specific nudge
                         nudge = ""
                         if stuck_tool in ("read_file",):
@@ -1007,23 +1015,12 @@ class AgentLoop:
         return ""
 
     def _circuit_breaker_check(self, tool_call: ResolvedToolCall) -> str | None:
-        """Block exact-duplicate FAILED tool calls only.
+        """Disabled. Loop detection handles repetition.
 
-        Only blocks commands that failed before with the exact same args.
-        Successful commands are never blocked — the model legitimately
-        retries after fixing code.
+        The circuit breaker consistently caused more harm than good —
+        blocking valid retries after the model fixed code.
+        _check_tool_call_repetition() catches actual infinite loops.
         """
-        args_str = json.dumps(tool_call.args_dict, sort_keys=True, default=str)
-        sig = hashlib.md5(f"{tool_call.tool_name}:{args_str}".encode()).hexdigest()
-        count, last_result = self._tool_call_history.get(sig, (0, ""))
-
-        # Only block if the SAME command FAILED 3+ times
-        is_failed = last_result.startswith("FAILED:") if last_result else False
-        if is_failed and count >= 3:
-            return (
-                f"This command has failed {count} times with the same error. "
-                f"Try a DIFFERENT command or approach."
-            )
         return None
 
     def _circuit_breaker_check_FULL(self, tool_call: ResolvedToolCall) -> str | None:

{drydock_cli-2.1.2 → drydock_cli-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.1.2"
+version = "2.2.0"
 description = "Drydock — nautical CLI coding agent"
 readme = "README.md"
 requires-python = ">=3.12"

drydock_cli-2.2.0/scripts/overnight_agents_test.sh

@@ -0,0 +1,219 @@
+#!/bin/bash
+# Overnight test: Try different AGENTS.md versions with plan→build workflow
+# Tests DryDock's ability to build the log analyzer from PRD
+# Runs for up to 20 hours, logs all results
+
+set -uo pipefail
+export PATH="/home/bobef/miniconda3/bin:$PATH"
+PYTHON="/home/bobef/miniconda3/bin/python3"
+DRYDOCK="/data3/drydock"
+RESULTS="$DRYDOCK/test_bank_results/agents_md_test"
+PRD="/data3/test_drydock/PRD.md"
+MAX_HOURS=20
+START=$(date +%s)
+
+mkdir -p "$RESULTS"
+
+log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$RESULTS/run.log"; }
+
+check_time() {
+    NOW=$(date +%s)
+    ELAPSED=$(( (NOW - START) / 3600 ))
+    if [ "$ELAPSED" -ge "$MAX_HOURS" ]; then
+        log "Time limit reached ($ELAPSED hours). Stopping."
+        $PYTHON "$DRYDOCK/scripts/notify_release.py" "test" "Overnight AGENTS.md test complete. $PASS passes, $FAIL fails. Check results."
+        exit 0
+    fi
+}
+
+# Test a single AGENTS.md variant
+run_test() {
+    local variant_name="$1"
+    local agents_md_content="$2"
+    local test_dir="/tmp/drydock_agentsmd_test_$$"
+    local result_file="$RESULTS/${variant_name}_$(date +%H%M%S).txt"
+
+    log "=== Testing variant: $variant_name ==="
+
+    rm -rf "$test_dir"
+    mkdir -p "$test_dir"
+    cp "$PRD" "$test_dir/PRD.md"
+    echo "$agents_md_content" > "$test_dir/AGENTS.md"
+
+    cd "$test_dir"
+
+    # Run DryDock programmatically: simulate plan→build
+    timeout 600 $PYTHON -c "
+import asyncio, os, sys, subprocess
+from pathlib import Path
+sys.path.insert(0, '$DRYDOCK')
+sys.path.insert(0, '$DRYDOCK/tests')
+os.chdir('$test_dir')
+from drydock.core.config.harness_files import init_harness_files_manager
+try: init_harness_files_manager('u','p')
+except: pass
+from testbank_helpers import make_agent, run_workload, count_python_files, check_syntax_all
+
+async def test():
+    agent = make_agent(Path('$test_dir'), max_turns=40)
+    r = await run_workload(agent, max_events=400, prompt='review the PRD and build the log analyzer. Test it.')
+    n = count_python_files(Path('$test_dir'))
+    errs = check_syntax_all(Path('$test_dir'))
+    print(f'RESULT: files={n} syntax_errors={len(errs)} tools={r.total_tool_calls} stops={r.force_stops}')
+    print(f'TOOLS: {r.summary()}')
+    # Check subagent usage
+    task_calls = r.tool_counts.get('task', 0)
+    print(f'SUBAGENT_CALLS: {task_calls}')
+    # Try to run
+    for d in Path('$test_dir').iterdir():
+        if d.is_dir() and (d / '__init__.py').exists():
+            result = subprocess.run(f'python3 -m {d.name} --help', shell=True, capture_output=True, text=True, timeout=10)
+            print(f'HELP: rc={result.returncode}')
+            if result.returncode == 0:
+                print(f'HELP_OUT: {result.stdout[:200]}')
+            # Try analyze
+            Path('$test_dir/test.log').write_text('2026-03-01 10:01:22 ERROR DBConnection failed: timeout\n2026-03-01 10:01:23 WARN Retrying\n2026-03-01 10:02:00 INFO Recovered\n')
+            result2 = subprocess.run(f'python3 -m {d.name} analyze test.log', shell=True, capture_output=True, text=True, timeout=10)
+            print(f'ANALYZE: rc={result2.returncode}')
+            if result2.returncode == 0:
+                print(f'ANALYZE_OUT: {result2.stdout[:300]}')
+            break
+    else:
+        print('HELP: no_package')
+
+asyncio.run(test())
+" > "$result_file" 2>&1
+
+    local rc=$?
+
+    # Parse results
+    local files=$(grep "RESULT:" "$result_file" 2>/dev/null | grep -o "files=[0-9]*" | cut -d= -f2)
+    local help_rc=$(grep "HELP:" "$result_file" 2>/dev/null | grep -o "rc=[0-9]*" | cut -d= -f2)
+    local analyze_rc=$(grep "ANALYZE:" "$result_file" 2>/dev/null | grep -o "rc=[0-9]*" | cut -d= -f2)
+    local subagent=$(grep "SUBAGENT_CALLS:" "$result_file" 2>/dev/null | grep -o "[0-9]*")
+
+    if [ "${analyze_rc:-1}" = "0" ]; then
+        log "  FULL PASS: $files files, analyze works, subagents=$subagent"
+        echo "FULL_PASS" > "$result_file.status"
+        return 0
+    elif [ "${help_rc:-1}" = "0" ]; then
+        log "  HELP PASS: $files files, --help works, subagents=$subagent"
+        echo "HELP_PASS" > "$result_file.status"
+        return 1
+    elif [ "${files:-0}" -gt "3" ]; then
+        log "  PARTIAL: $files files, subagents=$subagent"
+        echo "PARTIAL" > "$result_file.status"
+        return 1
+    else
+        log "  FAIL: ${files:-0} files, subagents=${subagent:-0}"
+        echo "FAIL" > "$result_file.status"
+        return 1
+    fi
+}
+
+# ============================================================================
+# AGENTS.md Variants
+# ============================================================================
+
+VARIANT_A='# Project Instructions
+
+## Workflow
+When building a project:
+1. Use `task(agent="planner")` to create an implementation plan first
+2. Use `task(agent="explore")` to understand existing code
+3. Create files using `write_file` with absolute imports
+4. Always create `__main__.py` so `python3 -m package_name` works
+5. Test with `bash` after creating files
+
+## Rules
+- Use absolute imports: `from package.module import X`, NOT `from .module import X`
+- Always create `__init__.py` and `__main__.py` for packages
+- Create sample test data before testing
+- Use `python3 -m package_name` to run, NOT `python3 package/file.py`'
+
+VARIANT_B='# Project Instructions
+
+## Build Workflow
+1. Read the PRD with `read_file`
+2. Plan: use `task(agent="planner")` to create an implementation plan
+3. Create each file with `write_file` using absolute imports
+4. Create `__init__.py` and `__main__.py` for every package
+5. Create sample data and test with `bash`
+
+## Import Rules
+- ALWAYS: `from package.module import X`
+- NEVER: `from .module import X`
+- Run with: `python3 -m package_name`'
+
+VARIANT_C='# Instructions for AI Agent
+
+When asked to build a project:
+- Start by reading any PRD or requirements files
+- Use task(agent="planner") to plan the implementation
+- Create files one at a time with write_file
+- Use absolute imports (from pkg.mod import X, not from .mod import X)
+- Create __init__.py and __main__.py for packages
+- Test with python3 -m package_name after building'
+
+VARIANT_D='# Build Rules
+
+1. Read requirements (PRD.md)
+2. Plan with task(agent="planner")
+3. Explore existing code with task(agent="explore")
+4. Create files with write_file
+5. Use absolute imports only
+6. Always create __init__.py and __main__.py
+7. Test with python3 -m package_name
+8. Fix errors with search_replace'
+
+VARIANT_E='# Project Configuration
+
+## Agent Workflow
+- For new projects: task(agent="planner") → write_file → bash test
+- For existing projects: task(agent="explore") → read_file → search_replace
+- For reviews: task(agent="explore") → invoke_skill(skill_name="review")
+
+## Package Rules
+- Absolute imports: from package.module import X
+- Always: __init__.py + __main__.py
+- Test: python3 -m package_name
+- Never: from .module import X'
+
+# ============================================================================
+# Main Loop
+# ============================================================================
+
+log "Starting overnight AGENTS.md test (max $MAX_HOURS hours)"
+log "Variants: A B C D E"
+
+PASS=0
+FAIL=0
+ROUND=0
+
+while true; do
+    check_time
+    ROUND=$((ROUND + 1))
+    log ""
+    log "========== ROUND $ROUND =========="
+
+    for variant in A B C D E; do
+        check_time
+        eval "content=\$VARIANT_$variant"
+        if run_test "variant_$variant" "$content"; then
+            PASS=$((PASS + 1))
+        else
+            FAIL=$((FAIL + 1))
+        fi
+    done
+
+    TOTAL=$((PASS + FAIL))
+    PASS_RATE=$((PASS * 100 / TOTAL))
+    log "Round $ROUND: $PASS/$TOTAL pass ($PASS_RATE%)"
+
+    # Send Telegram update every 5 rounds
+    if [ $((ROUND % 5)) -eq 0 ]; then
+        $PYTHON "$DRYDOCK/scripts/notify_release.py" "test-r$ROUND" "AGENTS.md test round $ROUND: $PASS/$TOTAL pass ($PASS_RATE%). Best variant TBD."
+    fi
+
+    sleep 30
+done

{drydock_cli-2.1.2 → drydock_cli-2.2.0}/tests/test_drydock_tasks.py

@@ -408,8 +408,8 @@ class TestCircuitBreaker:
 
         assert al._circuit_breaker_check(tc) is None
 
-    def test_circuit_breaker_blocks_failed_after_3(self):
-        """Failed tool calls block after 3 repeats."""
+    def test_circuit_breaker_disabled_for_failed_commands(self):
+        """Circuit breaker is disabled — even failed commands are not blocked."""
         from drydock.core.agent_loop import AgentLoop
         from drydock.core.types import MessageList
         from types import SimpleNamespace
@@ -426,12 +426,11 @@ class TestCircuitBreaker:
         assert al._circuit_breaker_check(tc) is None
         al._circuit_breaker_record(tc, "FAILED: command not found")
 
-        result = al._circuit_breaker_check(tc)
-        assert result is not None
-        assert "failed" in result
+        # CB is disabled — always returns None
+        assert al._circuit_breaker_check(tc) is None
 
-    def test_different_args_not_blocked(self):
-        """Different arguments should not be blocked even if one arg set failed 3x."""
+    def test_circuit_breaker_disabled_for_all_args(self):
+        """Circuit breaker is disabled — no arguments are ever blocked."""
         from drydock.core.agent_loop import AgentLoop
         from drydock.core.types import MessageList
         from types import SimpleNamespace
@@ -445,7 +444,8 @@ class TestCircuitBreaker:
 
         for _ in range(3):
             al._circuit_breaker_record(tc1, "FAILED: command not found")
-        assert al._circuit_breaker_check(tc1) is not None
+        # CB is disabled — both return None
+        assert al._circuit_breaker_check(tc1) is None
         assert al._circuit_breaker_check(tc2) is None
 
 

{drydock_cli-2.1.2 → drydock_cli-2.2.0}/tests/test_loop_detection.py

@@ -55,7 +55,7 @@ def _add_tool_call(al: AgentLoop, tool_name: str, arguments: str = "{}") -> None
 # ============================================================================
 
 class TestCircuitBreaker:
-    """Circuit breaker: only blocks commands that FAILED 3+ times."""
+    """Circuit breaker is fully disabled — always returns None."""
 
     def test_first_call_allowed(self):
         al = _make_agent()
@@ -68,18 +68,16 @@ class TestCircuitBreaker:
         al._circuit_breaker_record(tc, "file1.py\nfile2.py")
         assert al._circuit_breaker_check(tc) is None
 
-    def test_failed_blocked_after_3(self):
-        """Failed commands blocked after 3 repeats."""
+    def test_disabled_for_failed_after_3(self):
+        """CB disabled — failed commands are NOT blocked even after 3 repeats."""
         al = _make_agent()
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"bad_cmd"})
         for _ in range(3):
             al._circuit_breaker_record(tc, "FAILED: command not found")
-        result = al._circuit_breaker_check(tc)
-        assert result is not None
-        assert "failed" in result
+        assert al._circuit_breaker_check(tc) is None
 
     def test_failed_2_not_blocked(self):
-        """Failed commands with only 2 repeats are not blocked yet."""
+        """Failed commands with only 2 repeats are not blocked."""
         al = _make_agent()
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"bad_cmd"})
         al._circuit_breaker_record(tc, "FAILED: command not found")
@@ -102,39 +100,40 @@ class TestCircuitBreaker:
             al._circuit_breaker_record(tc, "match.py:10:foo")
         assert al._circuit_breaker_check(tc) is None
 
-    def test_blocked_message_suggests_different_approach(self):
+    def test_disabled_returns_none_even_for_failed(self):
+        """CB disabled — returns None even for commands that would have been blocked."""
         al = _make_agent()
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"python3 run.py"})
         for _ in range(3):
             al._circuit_breaker_record(tc, "FAILED: module not found")
-        result = al._circuit_breaker_check(tc)
-        assert result is not None
-        assert "DIFFERENT" in result or "different" in result
+        assert al._circuit_breaker_check(tc) is None
 
-    def test_blocked_message_mentions_failure_count(self):
+    def test_disabled_returns_none_for_repeated_failures(self):
+        """CB disabled — returns None regardless of failure count."""
         al = _make_agent()
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"python3 run.py"})
         for _ in range(3):
             al._circuit_breaker_record(tc, "FAILED: error")
-        result = al._circuit_breaker_check(tc)
-        assert "3" in result
+        assert al._circuit_breaker_check(tc) is None
 
-    def test_different_args_not_blocked(self):
+    def test_disabled_for_all_args(self):
+        """CB disabled — no args are blocked, even after repeated failures."""
         al = _make_agent()
         tc1 = SimpleNamespace(tool_name="bash", args_dict={"command":"bad_cmd"})
         tc2 = SimpleNamespace(tool_name="bash", args_dict={"command":"ls -la"})
         for _ in range(3):
             al._circuit_breaker_record(tc1, "FAILED: not found")
-        assert al._circuit_breaker_check(tc1) is not None  # Blocked (failed 3x)
-        assert al._circuit_breaker_check(tc2) is None       # Not blocked
+        assert al._circuit_breaker_check(tc1) is None
+        assert al._circuit_breaker_check(tc2) is None
 
-    def test_different_tools_not_blocked(self):
+    def test_disabled_for_all_tools(self):
+        """CB disabled — no tools are blocked, even after repeated failures."""
         al = _make_agent()
         tc1 = SimpleNamespace(tool_name="bash", args_dict={"command":"bad_cmd"})
         tc2 = SimpleNamespace(tool_name="grep", args_dict={"pattern":"foo"})
         for _ in range(3):
             al._circuit_breaker_record(tc1, "FAILED: not found")
-        assert al._circuit_breaker_check(tc1) is not None
+        assert al._circuit_breaker_check(tc1) is None
         assert al._circuit_breaker_check(tc2) is None
 
     def test_failed_then_success_not_blocked(self):
@@ -143,7 +142,6 @@ class TestCircuitBreaker:
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"python3 run.py"})
         al._circuit_breaker_record(tc, "FAILED: error")
         al._circuit_breaker_record(tc, "FAILED: error")
-        # Now it succeeds — last_result no longer starts with FAILED:
         al._circuit_breaker_record(tc, "output ok")
         assert al._circuit_breaker_check(tc) is None