drydock-cli 3.0.166__tar.gz → 3.0.170__tar.gz

{drydock_cli-3.0.166/drydock_cli.egg-info → drydock_cli-3.0.170}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.166
+Version: 3.0.170
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/drydock/agent.py

@@ -5,6 +5,7 @@ DryDock v3 — clean, provider-agnostic, no model-specific hacks.
 from __future__ import annotations
 
 import os
+import time as _time
 from dataclasses import dataclass, field
 from typing import Generator
 
@@ -47,7 +48,7 @@ from drydock.compaction import (
     maybe_compact, emergency_compact, is_context_length_error, is_image_load_error,
     extract_server_n_ctx,
 )
-from drydock.loop_detect import LoopTracker
+from drydock.loop_detect import LoopTracker, degenerate_argument
 from drydock.task_state import TaskState
 from drydock.verification import (
     looks_like_verification,
@@ -213,6 +214,13 @@ def run(
     verif_fail_counts: dict[str, int] = {}  # failure-summary -> times seen (Epic J3)
     verification_text = ""    # concatenated verification commands+results (coverage)
     coverage_nudges = 0       # bounded "your checks never touched X" nudges
+    # Time-aware effort governor (bench taxonomy: think-bound runs burn a 30-min
+    # window on 3-9 turns of reasoning). Once ANY turn's LLM call overruns the
+    # soft cap, every later turn in this request runs decisive: low effort, the
+    # forcing suffix, and a tight token cap. Sticky per request — persistent
+    # slowness doesn't flip-flop; a new user message resets it.
+    time_pressed = False
+    turn_soft_cap = float(config.get("turn_seconds_soft_cap", 240) or 0)
     recovery = RecoveryController(
         suppression_iterations=config.get("recovery_suppression_iterations",
                                           SUPPRESSION_ITERATIONS),
@@ -252,6 +260,15 @@ def run(
         retries = 0
         stall_retries = 0
         decisive = False  # over-think interrupt: force a short, single-action turn
+        if time_pressed:
+            # A prior turn overran the soft cap — stay decisive for the request.
+            decisive = True
+            turn_config = dict(turn_config)
+            turn_config["reasoning_effort"] = "low"
+            cur = int(turn_config.get("max_tokens", 8192) or 8192)
+            turn_config["max_tokens"] = min(cur, _DECISIVE_MAX_TOKENS)
+            state.current_effort = "low"
+        _turn_t0 = _time.monotonic()
         while retries < 2:
             try:
                 available = schemas()
@@ -266,6 +283,7 @@ def run(
                     phase=str(state.task.phase),
                     task_text=state.task.objective,
                     max_tools=turn_config.get("max_tools", DEFAULT_MAX_TOOLS),
+                    pin_tools=turn_config.get("pin_tools") or [],
                 )
                 for event in stream(
                     model=turn_config["model"],
@@ -280,6 +298,19 @@ def run(
                         yield event
                     elif isinstance(event, AssistantTurn):
                         assistant_turn = event
+                # Time-aware effort governor: this turn's wall time decides how
+                # hard the NEXT turns may think. Trigger once per request.
+                if (turn_soft_cap > 0 and not time_pressed
+                        and _time.monotonic() - _turn_t0 > turn_soft_cap):
+                    time_pressed = True
+                    _emit(state, "effort_governor", engaged=True,
+                          turn_seconds=round(_time.monotonic() - _turn_t0, 1),
+                          cap=turn_soft_cap)
+                    yield TextChunk(
+                        f"\n[turn took {int(_time.monotonic() - _turn_t0)}s — "
+                        "switching to decisive, low-effort steps for the rest of "
+                        "this task to protect the time budget.]\n"
+                    )
                 break  # success
             except StallRetry as _sr:
                 # Stalled/over-thought past stall_retry_secs (wall-time), OR collapsed
@@ -632,9 +663,27 @@ def run(
             # (its result changes → different pair each time).
             _same_outcome = loop_tracker.outcome_count(tc["name"], tc["input"], _raw_result)
 
+            # Escalating-argument loop (full166 bench, build-pmars): a repeated
+            # unit amplifying INSIDE the argument (mv x_temp -> x_temp_temp ->
+            # ...) makes every call unique and every mv "productive", blinding
+            # repeat/cycle/streak detection. The degenerate argument itself is
+            # the tell — flag it, warn the model, and score it as a repeated
+            # outcome so the stall streak escalates normally.
+            _degen_src = ""
+            if isinstance(tc.get("input"), dict):
+                _degen_src = str(tc["input"].get("command") or tc["input"].get("file_path") or "")
+            _degen = degenerate_argument(_degen_src)
+            if _degen:
+                result = (
+                    f"[NOTE: this argument contains '{_degen}' repeated many times "
+                    f"— you are compounding the same rename/step instead of making "
+                    f"progress. STOP amplifying it; go back to the original name/"
+                    f"path and take a different approach.]\n" + result
+                )
+
             # Verification evidence: if this Bash call was a test/check/exec, parse
             # its result so the completion gate knows whether it PASSED, not just ran.
-            _repeated_outcome = False
+            _repeated_outcome = bool(_degen)
             if tc["name"] == "Bash":
                 _vcmd = (tc.get("input") or {}).get("command", "")
                 if looks_like_verification(_vcmd):
@@ -674,7 +723,10 @@ def run(
                 # information" means the same call returned the SAME result again
                 # — a poll whose output changes each time is novel information and
                 # must not accrue stall (found suppressing legit polling).
-                changed_state=bool(tool_result and tool_result.changed_state),
+                # A degenerate-argument call gets NO state-change credit — the
+                # compounding rename "changes" the repo every time while going
+                # nowhere; crediting it would reset the stall streak forever.
+                changed_state=bool(tool_result and tool_result.changed_state) and not _degen,
                 repeat_count=_same_outcome,
                 failing_tests_before=_failing_before if _failing_after is not None else None,
                 failing_tests_after=_failing_after,

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/drydock/config.py

@@ -73,10 +73,24 @@ DEFAULTS: dict[str, object] = {
     # even when interleaved actions look productive. Polling is exempt (its
     # result changes each time).
     "recovery_same_outcome_threshold": 6,
+    # Time-aware effort governor: once any single LLM turn takes longer than this
+    # many seconds, the rest of the request runs decisive (low reasoning effort,
+    # tight token cap) to protect the time budget — a think-bound task otherwise
+    # burns a whole window on a handful of giant reasoning turns. 0 = off.
+    "turn_seconds_soft_cap": 240,
     # Verified-trajectory export (RSI training-data collection). When set to a path,
     # drydock writes the full task trajectory (system prompt + transcript) there at
     # task end; a benchmark harness keeps only verifier-passing ones. Empty = off.
     "trajectory_file": "",
+    # Tool names dynamic tool selection must NEVER trim (tool_select.py), on top
+    # of the built-in core coding set — e.g. ["WebSearch", "WebFetch"] keeps the
+    # web tools surfaced even on tasks whose text never mentions the web. Names
+    # not in the registry are ignored.
+    "pin_tools": [],
+    # URL substrings the web tools refuse: WebSearch drops matching results,
+    # WebFetch declines matching URLs (with a plain message, never an error).
+    # Used to keep benchmark/solution sites out of harvested training runs.
+    "web_denylist": [],
     "theme": "harbor",
     # Optional SECOND model ("advisor") for a stronger second opinion — e.g. a
     # Gemini OpenAI-compatible endpoint on another box. Empty = disabled. The

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/drydock/loop_detect.py

@@ -129,6 +129,34 @@ def runaway_repetition_len(
     return best
 
 
+def degenerate_argument(text, *, min_unit: int = 4, min_reps: int = 4) -> str | None:
+    """The repeated unit if `text` contains a substring of >= min_unit chars
+    consecutively repeated >= min_reps times — the signature of an
+    ESCALATING-ARGUMENT loop (observed: a model renaming a directory
+    `x_temp` -> `x_temp_temp` -> ... until the path held `_temp` 8+ times; every
+    command was unique and every mv "changed state", so repeat/cycle/streak
+    detection were all blind to it). Returns None for healthy text. Checked
+    against tool COMMANDS/PATHS only — content bodies legitimately repeat."""
+    if not text or not isinstance(text, str) or len(text) < min_unit * min_reps:
+        return None
+    n = len(text)
+    # For each candidate unit length, slide and count consecutive repeats.
+    # Linear slide is fine: commands/paths are short (O(64·n) worst case).
+    for p in range(min_unit, min(64, n // min_reps) + 1):
+        for i in range(0, n - p * min_reps + 1):
+            unit = text[i:i + p]
+            if not unit.strip():
+                continue
+            reps = 1
+            j = i + p
+            while j + p <= n and text[j:j + p] == unit:
+                reps += 1
+                j += p
+            if reps >= min_reps:
+                return unit
+    return None
+
+
 class LoopTracker:
     """Counts identical tool calls across a run and produces advisory notes."""
 

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/drydock/tool_select.py

@@ -49,10 +49,11 @@ _EXTERNAL_MUTATION = frozenset({
 _DISCOVERY_PHASES = frozenset({"understand", "discover", "plan"})
 
 
-def _priority(name: str, phase: str, task: str) -> int:
-    """Higher = keep. CORE tools sort above everything; the rest rank by phase
-    preference and task relevance so the cap drops the least-relevant first."""
-    if name in CORE_TOOLS:
+def _priority(name: str, phase: str, task: str, pinned: frozenset[str]) -> int:
+    """Higher = keep. CORE and pinned tools sort above everything; the rest rank
+    by phase preference and task relevance so the cap drops the least-relevant
+    first."""
+    if name in CORE_TOOLS or name in pinned:
         return 1000
     score = 50  # neutral default — unknown/uncategorised tools are still kept if room
     phase = (phase or "").lower()
@@ -79,19 +80,23 @@ def select_tools(
     phase: str = "",
     task_text: str = "",
     max_tools: int = DEFAULT_MAX_TOOLS,
+    pin_tools: list[str] | None = None,
 ) -> list[dict]:
     """Return the subset of `schemas` to expose this turn (PRD Epic F).
 
-    Keeps every core coding tool, prefers read/search while exploring, and
-    surfaces specialised families only when the task text mentions them —
-    trimming to `max_tools` only when the full set exceeds it. Order-preserving
-    for the kept tools so the model sees a stable list. Never raises."""
+    Keeps every core coding tool plus any `pin_tools` (config: user-chosen names
+    that must never be trimmed, e.g. the web tools for a research-heavy run),
+    prefers read/search while exploring, and surfaces specialised families only
+    when the task text mentions them — trimming to `max_tools` only when the
+    full set exceeds it. Order-preserving for the kept tools so the model sees
+    a stable list. Never raises."""
     if not schemas or max_tools <= 0 or len(schemas) <= max_tools:
         return schemas
 
+    pinned = frozenset(pin_tools or ())
     ranked = sorted(
         schemas,
-        key=lambda s: _priority(s.get("name", ""), phase, task_text),
+        key=lambda s: _priority(s.get("name", ""), phase, task_text, pinned),
         reverse=True,
     )
     keep_names = {s.get("name") for s in ranked[:max_tools]}

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/drydock/tools/__init__.py

@@ -1863,8 +1863,16 @@ def tool_graphadd(params: dict, config: dict) -> str:
             "satisfies (`control`,`rule` — a STIG rule satisfies a NIST control).")
 
 
+def _web_denied(url: str, config: dict) -> bool:
+    deny = config.get("web_denylist") or []
+    low = (url or "").lower()
+    return any(str(pat).lower() in low for pat in deny if pat)
+
+
 def tool_websearch(params: dict, config: dict) -> str:
-    """Search the internet (DuckDuckGo). Read-only; clean message when offline."""
+    """Search the internet (DuckDuckGo). Read-only; clean message when offline.
+    Results matching config `web_denylist` are dropped before the model sees
+    them (kept out of harvested trajectories)."""
     from drydock import web
 
     query = _as_str_arg(params.get("query")).strip()
@@ -1878,7 +1886,12 @@ def tool_websearch(params: dict, config: dict) -> str:
         results = web.search(query, k=max(1, min(k, 10)))
     except web.WebError as e:
         return f"Web search unavailable: {e}. You appear to be offline — answer from your own knowledge."
-    return web.format_search(query, results)
+    kept = [r for r in results if not _web_denied(r.get("url", ""), config)]
+    dropped = len(results) - len(kept)
+    out = web.format_search(query, kept)
+    if dropped:
+        out += f"\n({dropped} result(s) withheld by site policy.)"
+    return out
 
 
 def tool_webfetch(params: dict, config: dict) -> str:
@@ -1888,6 +1901,8 @@ def tool_webfetch(params: dict, config: dict) -> str:
     url = _as_str_arg(params.get("url")).strip()
     if not url:
         return "Error: `WebFetch` needs a `url`."
+    if _web_denied(url, config):
+        return "That site is not available in this session. Solve the task from other sources."
     try:
         mc = int(params.get("max_chars") or 6000)
     except (TypeError, ValueError):

{drydock_cli-3.0.166 → drydock_cli-3.0.170/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.166
+Version: 3.0.170
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/drydock_cli.egg-info/SOURCES.txt

@@ -96,10 +96,12 @@ tests/test_context_limit_config.py
 tests/test_context_limit_issue25.py
 tests/test_criteria_coverage.py
 tests/test_cycling_detection.py
+tests/test_degenerate_argument.py
 tests/test_detect.py
 tests/test_dispatch.py
 tests/test_e2e_connected.py
 tests/test_edit_replace_all.py
+tests/test_effort_governor.py
 tests/test_empty_response.py
 tests/test_events.py
 tests/test_extract.py

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.166"
+version = "3.0.170"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.170/tests/test_degenerate_argument.py

@@ -0,0 +1,78 @@
+"""Regression for the full166 build-pmars finding: an ESCALATING-ARGUMENT loop
+(mv x_temp -> x_temp_temp -> ...) makes every call unique and every mv look
+productive — the amplifying unit inside the argument is the only tell."""
+from __future__ import annotations
+
+import tempfile
+
+import drydock.agent as agent_mod
+from drydock.agent import AgentState, run
+from drydock.loop_detect import degenerate_argument
+from drydock.providers import AssistantTurn
+
+
+def test_detects_the_pmars_spiral():
+    path = "/app/pmars_source" + "_temp" * 9
+    assert degenerate_argument(f"mv {path} /app/x") == "_temp"
+
+
+def test_healthy_commands_pass():
+    for cmd in (
+        "mv /app/pmars_source_temp /app/pmars",     # one _temp is fine
+        "python3 -m pytest tests/test_loop_detect.py -q",
+        "ls -la /app && cat /app/README.md",
+        "grep -rn 'def main' src/",
+        "echo hello world",
+    ):
+        assert degenerate_argument(cmd) is None, cmd
+
+
+def test_whitespace_units_ignored():
+    assert degenerate_argument("echo 'a" + "    " * 20 + "b'") is None
+
+
+def _renaming_spiral(base):
+    """Model that alternates mv (arg grows a _temp each time) with ls — the
+    exact build-pmars pattern: every command unique, every mv 'productive'."""
+    def stream(**kw):
+        n = stream.n
+        stream.n += 1
+        if n % 2 == 0:
+            suffix = "_temp" * (4 + n // 2)
+            tc = {"id": str(n), "name": "Bash",
+                  "input": {"command": f"mv {base} {base}{suffix} 2>/dev/null; true"}}
+        else:
+            tc = {"id": str(n), "name": "Bash", "input": {"command": f"ls {base} 2>/dev/null; true"}}
+        return iter([AssistantTurn("", [tc], 1, 1)])
+    stream.n = 0
+    return stream
+
+
+def test_spiral_is_stopped_by_escalation(monkeypatch):
+    d = tempfile.mkdtemp()
+    monkeypatch.setattr(agent_mod, "stream", _renaming_spiral(f"{d}/src"))
+    st = AgentState()
+    list(run("extract the source and build it", st,
+             {"model": "m", "cwd": d, "verify_gate": False, "max_turns": 60}, "sys"))
+    # The spiral must be cut well short of the 60-turn ceiling, with the
+    # degenerate-argument note visible to the model along the way.
+    assert st.turn_count < 40, f"spiral ran {st.turn_count} turns"
+    tool_msgs = [m.get("content", "") for m in st.messages if m.get("role") == "tool"]
+    assert any("repeated many times" in c for c in tool_msgs)
+
+
+def test_healthy_distinct_work_unaffected(monkeypatch):
+    d = tempfile.mkdtemp()
+    seq = [
+        AssistantTurn("", [{"id": "1", "name": "Bash",
+                            "input": {"command": f"mkdir -p {d}/a && touch {d}/a/x"}}], 1, 1),
+        AssistantTurn("", [{"id": "2", "name": "Bash",
+                            "input": {"command": f"mv {d}/a {d}/b"}}], 1, 1),
+        AssistantTurn("done", [], 1, 1),
+    ]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    st = AgentState()
+    list(run("reorganize", st, {"model": "m", "cwd": d, "verify_gate": False}, "sys"))
+    assert any(m.get("content") == "done" for m in st.messages)
+    tool_msgs = [m.get("content", "") for m in st.messages if m.get("role") == "tool"]
+    assert not any("repeated many times" in c for c in tool_msgs)

drydock_cli-3.0.170/tests/test_effort_governor.py

@@ -0,0 +1,81 @@
+"""Tests for the time-aware effort governor: a turn overrunning the soft cap
+flips the rest of the request to decisive (low effort, tight token cap, forcing
+suffix). Sticky per request; cap=0 disables."""
+from __future__ import annotations
+
+import tempfile
+import time
+
+import drydock.agent as agent_mod
+from drydock.agent import _DECISIVE_MAX_TOKENS, AgentState, run
+from drydock.providers import AssistantTurn
+
+
+def _slow_then_fast(captured):
+    """Turn 1 sleeps past the cap; later turns record the config they were
+    called with."""
+    def stream(**kw):
+        n = stream.n
+        stream.n += 1
+        captured.append({
+            "effort": kw.get("config", {}).get("reasoning_effort"),
+            "max_tokens": kw.get("config", {}).get("max_tokens"),
+            "decisive_suffix": "DECISIVE" in (kw.get("system") or "").upper()
+                                or "single" in (kw.get("system") or "").lower(),
+        })
+        if n == 0:
+            time.sleep(0.05)  # overruns the tiny test cap
+            return iter([AssistantTurn(
+                "", [{"id": "1", "name": "Bash", "input": {"command": "echo hi"}}], 1, 1)])
+        if n == 1:
+            return iter([AssistantTurn(
+                "", [{"id": "2", "name": "Bash", "input": {"command": "echo again"}}], 1, 1)])
+        return iter([AssistantTurn("done", [], 1, 1)])
+    stream.n = 0
+    return stream
+
+
+def test_overrun_turn_flips_request_to_decisive(monkeypatch):
+    captured: list = []
+    monkeypatch.setattr(agent_mod, "stream", _slow_then_fast(captured))
+    st = AgentState()
+    list(run("do things", st,
+             {"model": "m", "cwd": tempfile.mkdtemp(), "verify_gate": False,
+              "turn_seconds_soft_cap": 0.01}, "sys"))
+    assert len(captured) >= 3
+    # turn 1 ran normally; turns 2+ are decisive
+    assert captured[1]["effort"] == "low"
+    assert captured[1]["max_tokens"] == _DECISIVE_MAX_TOKENS
+    assert captured[2]["effort"] == "low"
+    # the run still completes normally
+    assert any(m.get("content") == "done" for m in st.messages)
+
+
+def test_cap_zero_disables_governor(monkeypatch):
+    captured: list = []
+    monkeypatch.setattr(agent_mod, "stream", _slow_then_fast(captured))
+    st = AgentState()
+    list(run("do things", st,
+             {"model": "m", "cwd": tempfile.mkdtemp(), "verify_gate": False,
+              "turn_seconds_soft_cap": 0}, "sys"))
+    # no decisive flip: later turns keep whatever effort the normal logic picked
+    assert captured[1]["max_tokens"] != _DECISIVE_MAX_TOKENS
+
+
+def test_fast_turns_never_trigger(monkeypatch):
+    captured: list = []
+
+    def fast(**kw):
+        n = fast.n; fast.n += 1
+        captured.append({"max_tokens": kw.get("config", {}).get("max_tokens")})
+        if n == 0:
+            return iter([AssistantTurn(
+                "", [{"id": "1", "name": "Bash", "input": {"command": "echo hi"}}], 1, 1)])
+        return iter([AssistantTurn("done", [], 1, 1)])
+    fast.n = 0
+    monkeypatch.setattr(agent_mod, "stream", fast)
+    st = AgentState()
+    list(run("quick", st,
+             {"model": "m", "cwd": tempfile.mkdtemp(), "verify_gate": False,
+              "turn_seconds_soft_cap": 240}, "sys"))
+    assert captured[1]["max_tokens"] != _DECISIVE_MAX_TOKENS

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/tests/test_resume_restore.py

@@ -54,6 +54,37 @@ def test_unresolved_external_mutation_is_unsafe(tmp_path):
     assert any("verify before retrying" in w for w in info.warnings)
 
 
+def test_restore_falls_back_to_snapshotted_events_path(tmp_path):
+    # Snapshot records the session's event-trace path; restore() without an
+    # explicit event_trace must still find the unresolved calls through it.
+    ev = EventLog(tmp_path / "t.jsonl")
+    ev.emit("tool_started", name="Bash", effect="local_mutation")
+    st = AgentState()
+    st.task = TaskState.from_objective("x")
+    st.messages = [{"role": "user", "content": "x"}]
+    st.events = ev
+    path = tmp_path / "s.json"
+    resume.save_snapshot(st, {"model": "gemma4", "cwd": "/repo", "session_id": "sess"}, path)
+    info = resume.restore(path)
+    assert len(info.unresolved) == 1
+    assert info.unresolved[0]["name"] == "Bash"
+
+
+def test_explicit_event_trace_overrides_snapshotted_path(tmp_path):
+    ev_snap = EventLog(tmp_path / "snap.jsonl")
+    ev_snap.emit("tool_started", name="Read", effect="read_only")
+    st = AgentState()
+    st.task = TaskState.from_objective("x")
+    st.messages = [{"role": "user", "content": "x"}]
+    st.events = ev_snap
+    path = tmp_path / "s.json"
+    resume.save_snapshot(st, {"model": "gemma4", "cwd": "/repo", "session_id": "sess"}, path)
+    ev_other = EventLog(tmp_path / "other.jsonl")
+    ev_other.emit("tool_started", name="Write", effect="local_mutation")
+    info = resume.restore(path, ev_other.path)
+    assert [u["name"] for u in info.unresolved] == ["Write"]
+
+
 def test_apply_to_state_restores_session(tmp_path):
     path = _snapshot(tmp_path, [{"role": "user", "content": "build a thing"},
                                 {"role": "assistant", "content": "working"}])

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/tests/test_tool_select.py

@@ -84,3 +84,26 @@ def test_empty_and_degenerate_inputs():
     assert select_tools([], max_tools=12) == []
     s = _schemas(["Read", "Bash"])
     assert select_tools(s, max_tools=0) == s  # cap<=0 disables trimming
+
+
+def test_pin_tools_survive_trimming_on_unrelated_task():
+    # Web tools are normally first out on a non-web task; pinning keeps them.
+    out = select_tools(_schemas(ALL), phase="implement",
+                       task_text="fix the failing unit test in parser.py",
+                       max_tools=10, pin_tools=["WebSearch", "WebFetch"])
+    names = _names(out)
+    assert "WebSearch" in names and "WebFetch" in names
+    assert CORE_TOOLS <= names
+
+
+def test_unpinned_web_tools_still_trimmed_on_unrelated_task():
+    out = select_tools(_schemas(ALL), phase="implement",
+                       task_text="fix the failing unit test in parser.py",
+                       max_tools=10)
+    assert "WebSearch" not in _names(out)
+
+
+def test_pin_tools_unknown_names_ignored():
+    out = select_tools(_schemas(ALL), max_tools=10,
+                       pin_tools=["NoSuchTool"])
+    assert "NoSuchTool" not in _names(out)

{drydock_cli-3.0.166 → drydock_cli-3.0.170}/tests/test_web_tools.py

@@ -103,3 +103,31 @@ def test_fetch_truncates_long_text(monkeypatch):
 
 def test_format_search_empty():
     assert "No web results" in web.format_search("rare query", [])
+
+
+def test_websearch_denylist_drops_matching_results(monkeypatch):
+    from drydock.tools import tool_websearch
+    monkeypatch.setattr(web, "search", lambda q, k=5: [
+        {"url": "https://github.com/laude-institute/terminal-bench/x", "title": "sol", "snippet": ""},
+        {"url": "https://docs.python.org/3/", "title": "docs", "snippet": ""},
+    ])
+    out = tool_websearch({"query": "q"}, {"web_denylist": ["laude-institute", "terminal-bench"]})
+    assert "docs.python.org" in out
+    assert "laude-institute" not in out
+    assert "withheld" in out
+
+
+def test_webfetch_denylist_declines_without_error():
+    from drydock.tools import tool_webfetch
+    out = tool_webfetch({"url": "https://github.com/laude-institute/terminal-bench/solution.sh"},
+                        {"web_denylist": ["terminal-bench"]})
+    assert "not available" in out
+    assert "Error" not in out
+
+
+def test_web_tools_no_denylist_config_unaffected(monkeypatch):
+    from drydock.tools import tool_websearch
+    monkeypatch.setattr(web, "search", lambda q, k=5: [
+        {"url": "https://example.com", "title": "t", "snippet": "s"}])
+    out = tool_websearch({"query": "q"}, {})
+    assert "example.com" in out and "withheld" not in out