drydock-cli 2.9.113__tar.gz → 2.9.115__tar.gz

{drydock_cli-2.9.113 → drydock_cli-2.9.115}/PKG-INFO

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

{drydock_cli-2.9.113 → drydock_cli-2.9.115}/drydock/core/agent_loop.py

@@ -182,6 +182,61 @@ def _should_raise_rate_limit_error(e: Exception) -> bool:
     return isinstance(e, BackendError) and e.status == HTTPStatus.TOO_MANY_REQUESTS
 
 
+def _probe_backend_context_window(active_model: Any) -> int | None:
+    """Probe a llama.cpp-style backend's runtime context window via its
+    /props endpoint.
+
+    Returns the integer n_ctx (the value the server was started with via
+    `-c <N>`), or None if the probe fails for any reason. Failure cases
+    that should silently fall through to the static config value:
+      - non-llama.cpp backend (no /props endpoint)
+      - network error, timeout, malformed JSON, missing field
+      - no base_url configured (cloud-backed models like Mistral API)
+
+    Why this exists: drydock's `context_window` setting historically
+    lived in `~/.drydock/config.toml` and got out of sync with the
+    backend's actual `-c <N>` parameter. The auto-compact threshold
+    clamps off `context_window - 4K`, so a 131K config against a 32K
+    backend never compacted -> context bloated past the wire limit ->
+    backend returned 400. The probe pulls the truth from the source.
+
+    llama.cpp exposes the runtime ctx in `/props` ->
+    `default_generation_settings.params.n_ctx`. Other servers (vLLM,
+    Ollama) expose different shapes; we silently fall through and let
+    the static config win there.
+    """
+    try:
+        base_url = getattr(active_model, "base_url", "") or ""
+    except Exception:
+        return None
+    if not base_url:
+        return None
+    # /props sits at the server root, not under /v1
+    root = base_url.rstrip("/")
+    if root.endswith("/v1"):
+        root = root[:-3]
+    probe_url = root + "/props"
+    try:
+        import urllib.request as _u
+        with _u.urlopen(probe_url, timeout=2) as resp:
+            d = json.loads(resp.read().decode("utf-8", errors="replace"))
+    except Exception:
+        return None
+    # Walk the JSON looking for n_ctx (llama.cpp's exact shape)
+    try:
+        v = d.get("default_generation_settings", {})
+        if isinstance(v, dict):
+            params = v.get("params", {}) or {}
+            n_ctx = params.get("n_ctx") or v.get("n_ctx")
+            if n_ctx:
+                return int(n_ctx)
+        if "n_ctx" in d:
+            return int(d["n_ctx"])
+    except Exception:
+        pass
+    return None
+
+
 class AgentLoop:
     def __init__(
         self,
@@ -745,6 +800,29 @@ class AgentLoop:
 
         active_model = self.config.get_active_model()
         _compact_thresh = active_model.auto_compact_threshold
+
+        # 2026-06-07 (v2.9.115): probe the live llama.cpp backend for its
+        # runtime n_ctx via /props, so the compact threshold reflects
+        # reality instead of a stale config value.
+        # User session: backends were unified at 32K but their config
+        # still listed context_window=131072 -> compact never fired ->
+        # context bloated past the actual 32K -> backend returned 400.
+        # The probe is HTTP-bound and gated by base_url presence, so it
+        # only fires for self-hosted models. On failure it silently
+        # falls through to the static config value.
+        probed_ctx = _probe_backend_context_window(active_model)
+        if probed_ctx and probed_ctx > 0:
+            probed_thresh = max(4_000, probed_ctx - 4_096)
+            static_ctx = getattr(active_model, "context_window", 0) or 0
+            if static_ctx != probed_ctx:
+                logger.warning(
+                    "[CONTEXT-PROBE] backend reports n_ctx=%d but config "
+                    "says context_window=%d. Using detected value. "
+                    "auto_compact_threshold: %d -> %d.",
+                    probed_ctx, static_ctx, _compact_thresh, probed_thresh,
+                )
+                _compact_thresh = probed_thresh
+
         _env_thresh = os.environ.get("DRYDOCK_AUTO_COMPACT_THRESHOLD", "")
         if _env_thresh.strip():
             try:
@@ -4208,20 +4286,39 @@ class AgentLoop:
             self._last_reflection_streak = 0
             return
         if effective_kind == "readonly":
-            # 2026-06-07 (v2.9.111): Only count toward the streak when this
-            # readonly call's RESULT was already seen in the recent window.
-            # Operator session 2026-06-07: model was doing legit diagnosis
-            # (ran script -> ls confirmed no output file -> read source ->
-            # cat showed contents -> hard-stop killed the turn before model
-            # could use what cat revealed). Counting every distinct read as
-            # "stuck" punished real exploration. The doom-loop signature is
-            # IDENTICAL results, not many results. Track a sliding window of
-            # recent result hashes; if the current hash repeats, the model
-            # is going in circles -> increment. If novel, the model is
-            # learning new info -> don't increment (don't reset either, so
-            # if loop resumes the streak picks up where it left off).
+            # 2026-06-07 (v2.9.111/v2.9.114): Only count toward the streak
+            # when this readonly call's RESULT was already seen in the
+            # recent window. The doom-loop signature is IDENTICAL results,
+            # not many results.
+            #
+            # v2.9.114 fix: strip dedup-advisory headers from result text
+            # BEFORE hashing. Otherwise read_file's escalating
+            # "[REPEATED READ #N]" headers produce a different hash every
+            # time, and the model's re-read loop looks "novel" forever.
+            # Operator session 2026-06-07 showed cli.py being re-read 6+
+            # times with each hitting a different advisory header (#2,
+            # #3, #4, …) — my v2.9.112 missed all of them.
+            # Also fast-path: any result that opens with a dedup advisory
+            # marker is by definition a duplicate-content read.
+            DEDUP_MARKERS = (
+                "[2nd identical read",
+                "[REPEATED READ",
+                "[2nd identical read of this file",
+            )
+            raw_text = text or ""
+            stripped_text = raw_text
+            forced_dup = False
+            # Strip leading dedup advisory header if present
+            if raw_text.startswith("[") and any(
+                m in raw_text[:200] for m in DEDUP_MARKERS
+            ):
+                # Header runs to the closing bracket; content begins after
+                idx = raw_text.find("]\n")
+                if idx > 0:
+                    stripped_text = raw_text[idx + 2 :]
+                forced_dup = True
             try:
-                content_for_hash = (text or "")[:8192]
+                content_for_hash = stripped_text[:8192]
                 cur_hash = hashlib.sha256(
                     content_for_hash.encode("utf-8", errors="replace")
                 ).hexdigest()[:16]
@@ -4230,17 +4327,14 @@ class AgentLoop:
             seen_window = self.__dict__.setdefault(
                 "_recent_readonly_hashes", []
             )
-            is_duplicate = bool(cur_hash) and cur_hash in seen_window
+            is_duplicate = forced_dup or (
+                bool(cur_hash) and cur_hash in seen_window
+            )
             if is_duplicate:
                 self._readonly_streak += 1
             # else: novel content -> productive readonly, don't increment.
-            #       Don't reset either: the streak is for cumulative
-            #       doom-loop behavior, not "did this single call help".
             if cur_hash:
                 seen_window.append(cur_hash)
-                # keep the last 30 — enough to catch real loops, small
-                # enough that a legit re-read after lots of new work
-                # doesn't false-trigger.
                 self._recent_readonly_hashes = seen_window[-30:]
             if not is_duplicate:
                 return

{drydock_cli-2.9.113 → drydock_cli-2.9.115}/pyproject.toml

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

{drydock_cli-2.9.113 → drydock_cli-2.9.115}/tests/test_loop_regressions_2026_06_06.py

@@ -350,6 +350,36 @@ class TestReadonlyStreakOnlyCountsDoomLoops:
             recent = recent[-30:]
         assert streak == 5
 
+    def test_v2_9_114_strips_dedup_headers_before_hash(self):
+        """v2.9.114: read_file's dedup advisory headers change every time
+        ([2nd identical read...], [REPEATED READ #3...], #4 etc.). Each
+        carries the same underlying file content but a unique header.
+        v2.9.112 hashed the full text and saw each as "novel", missing
+        the loop. v2.9.114 strips the leading [advisory] block before
+        hashing so the underlying content is the comparison key.
+
+        Direct test of the marker-detection fast path: any text starting
+        with the dedup marker is forced to count as duplicate even
+        without hash collision."""
+        DEDUP_MARKERS = (
+            "[2nd identical read",
+            "[REPEATED READ",
+        )
+        cases = [
+            ("[2nd identical read of this file - content is unchanged]\nfile contents go here", True),
+            ("[REPEATED READ #5: file has not changed across 5 reads]\nfile contents", True),
+            ("normal file output 1\nline 2\nline 3", False),
+            ("no header just content", False),
+        ]
+        for text, expected_forced_dup in cases:
+            forced_dup = text.startswith("[") and any(
+                m in text[:200] for m in DEDUP_MARKERS
+            )
+            assert forced_dup == expected_forced_dup, (
+                f"{text[:40]!r} -> forced_dup={forced_dup}, "
+                f"expected {expected_forced_dup}"
+            )
+
     def test_marker_present_in_agent_loop(self):
         text = open(
             "/data3/drydock/drydock/core/agent_loop.py"
@@ -358,6 +388,94 @@ class TestReadonlyStreakOnlyCountsDoomLoops:
         assert "doom-loop signature is" in text or "v2.9.111" in text
 
 
+class TestContextWindowProbe:
+    """v2.9.115: drydock probes the live llama.cpp backend's /props
+    endpoint at AgentLoop init to discover the runtime n_ctx, then
+    uses that to recompute auto_compact_threshold (instead of the
+    stale config value). Prevents the 32K backend / 131K config skew
+    that would let context bloat past the wire limit."""
+
+    def test_probe_extracts_n_ctx_from_llamacpp_props_shape(self):
+        """Verify the JSON walk that finds n_ctx in llama.cpp's exact
+        /props response shape."""
+        import json as _json
+        from unittest.mock import patch, MagicMock
+        from drydock.core.agent_loop import _probe_backend_context_window
+
+        class FakeModel:
+            base_url = "http://test:8000/v1"
+
+        # Mock urllib.request.urlopen to return the exact /props shape
+        # llama.cpp emits (the inner `default_generation_settings.params`
+        # dict carries the runtime n_ctx).
+        fake_resp = _json.dumps({
+            "default_generation_settings": {
+                "params": {
+                    "n_ctx": 32768,
+                    "temperature": 1.0,
+                },
+            },
+        }).encode()
+        mock_handle = MagicMock()
+        mock_handle.read.return_value = fake_resp
+        mock_handle.__enter__.return_value = mock_handle
+        mock_handle.__exit__.return_value = None
+
+        with patch("urllib.request.urlopen", return_value=mock_handle):
+            n = _probe_backend_context_window(FakeModel())
+        assert n == 32768
+
+    def test_probe_returns_none_when_no_base_url(self):
+        """Cloud-backed models (Mistral, Anthropic) have no base_url for
+        the llama.cpp /props endpoint — probe must short-circuit cleanly."""
+        from drydock.core.agent_loop import _probe_backend_context_window
+
+        class CloudModel:
+            base_url = ""
+
+        assert _probe_backend_context_window(CloudModel()) is None
+
+    def test_probe_returns_none_on_network_error(self):
+        """If the backend is unreachable, the probe must not raise — it
+        falls through to the static config value."""
+        from unittest.mock import patch
+        from drydock.core.agent_loop import _probe_backend_context_window
+
+        class FakeModel:
+            base_url = "http://nonexistent.invalid:8000/v1"
+
+        # Force urlopen to raise
+        with patch("urllib.request.urlopen", side_effect=OSError("nope")):
+            assert _probe_backend_context_window(FakeModel()) is None
+
+    def test_probe_handles_v1_suffix_correctly(self):
+        """base_url often ends in /v1 (OpenAI-compatible convention).
+        /props sits at the root, not under /v1. The probe must strip
+        /v1 before appending /props."""
+        from unittest.mock import patch, MagicMock
+        import json as _json
+        from drydock.core.agent_loop import _probe_backend_context_window
+
+        class FakeModel:
+            base_url = "http://test:8000/v1"
+
+        captured_url = {}
+        def fake_urlopen(url, timeout=None):
+            captured_url["u"] = url
+            mock = MagicMock()
+            mock.read.return_value = _json.dumps(
+                {"default_generation_settings": {"params": {"n_ctx": 32768}}}
+            ).encode()
+            mock.__enter__.return_value = mock
+            mock.__exit__.return_value = None
+            return mock
+
+        with patch("urllib.request.urlopen", side_effect=fake_urlopen):
+            _probe_backend_context_window(FakeModel())
+        # /v1 must be stripped before appending /props
+        assert captured_url["u"] == "http://test:8000/props"
+
+
 class TestGeneralizedDuplicatePreflight:
     """v2.9.108: the preflight handles ANY tool with 5+ identical-args
     calls, not just write_file. Verifies the v2.9.95 distribution-search

{drydock_cli-2.9.113 → drydock_cli-2.9.115}/uv.lock

@@ -326,7 +326,7 @@ wheels = [
 
 [[package]]
 name = "drydock-cli"
-version = "2.9.112"
+version = "2.9.114"
 source = { editable = "." }
 dependencies = [
     { name = "agent-client-protocol" },