drydock-cli 2.8.59__tar.gz → 2.8.61__tar.gz

drydock_cli-2.8.61/.auto_release.lock

@@ -0,0 +1 @@
+3062158

{drydock_cli-2.8.59 → drydock_cli-2.8.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.59
+Version: 2.8.61
 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.8.59 → drydock_cli-2.8.61}/drydock/admiral/detectors.py

@@ -19,6 +19,7 @@ WRITE_TOOLS: frozenset[str] = frozenset({"write_file", "search_replace", "edit_f
 class Finding:
     code: str          # stable ID used for dedup, e.g. "loop:write_file:/p/x.py"
     directive: str     # text to inject into the conversation
+    force_stop: bool = False  # True → interventions.apply also sets FORCE_STOP on the loop
 
 
 def _tool_sig(tc) -> str:  # ToolCall — keep loose to avoid circular import
@@ -90,7 +91,8 @@ def detect_struggle(messages: Sequence[LLMMessage], threshold: int = 20) -> Find
     # Previously included the count, which caused 33 identical interventions
     # in a single session (each with a unique key that bypassed dedup).
     code = f"struggle:{last_write_tool or 'none'}"
-    if calls_since_write >= 30:
+    severe = calls_since_write >= 30
+    if severe:
         if last_write_tool is None:
             directive = (
                 f"Admiral: you have made {calls_since_write} tool calls without "
@@ -115,7 +117,7 @@ def detect_struggle(messages: Sequence[LLMMessage], threshold: int = 20) -> Find
             f"Admiral: you have made {calls_since_write} tool calls without "
             f"writing or editing any file. {hint}"
         )
-    return Finding(code=code, directive=directive)
+    return Finding(code=code, directive=directive, force_stop=severe)
 
 
 def run_all(messages: Sequence[LLMMessage]) -> list[Finding]:

{drydock_cli-2.8.59 → drydock_cli-2.8.61}/drydock/admiral/interventions.py

@@ -19,3 +19,9 @@ def apply(agent_loop: AgentLoop, finding: Finding) -> None:
     """Inject the finding's directive into the live conversation."""
     agent_loop._inject_system_note(finding.directive)
     history.append("intervention", f"{finding.code} :: {finding.directive[:160]}")
+    if finding.force_stop:
+        # Severe struggle (≥30 read-only calls) — advisory alone doesn't break
+        # the loop. Set FORCE_STOP so the next LLM call uses tool_choice=none,
+        # forcing the model to emit text rather than keep exploring.
+        agent_loop._loop_detected = True
+        agent_loop._loop_signal = "FORCE_STOP"

{drydock_cli-2.8.59 → drydock_cli-2.8.61}/drydock/admiral/worker.py

@@ -160,7 +160,7 @@ class AdmiralWorker:
                 "directive-source",
                 f"{finding.code} :: source={source}",
             )
-            finding_with_text = type(finding)(code=finding.code, directive=directive)
+            finding_with_text = type(finding)(code=finding.code, directive=directive, force_stop=finding.force_stop)
             interventions.apply(self.agent_loop, finding_with_text)
 
             # Watch for re-fires within the fail window to classify this

{drydock_cli-2.8.59 → drydock_cli-2.8.61}/drydock/core/agent_loop.py

@@ -901,7 +901,11 @@ class AgentLoop:
             _prompt_start = time.perf_counter()
             _time_stop_injected = False
             _time_stop_escalated = False
-            _tool_stop_injected = False
+            # Promoted to self._tool_stop_injected so _perform_llm_turn
+            # (a separate method, different scope) can read+write it.
+            # The four read sites at lines ~1459/1538/1594/1661 live in
+            # _perform_llm_turn and were raising NameError previously.
+            self._tool_stop_injected = False
             logger.warning("[TIMING] entering conversation while loop")
             while not should_break_loop:
                 # Drain any user messages typed while the agent was working.
@@ -987,9 +991,9 @@ class AgentLoop:
                         + (f" {_stop_suffix}" if _stop_suffix else "")
                     )
                 if (TOOL_STOP_AFTER > 0
-                        and not _tool_stop_injected
+                        and not self._tool_stop_injected
                         and tool_turns >= TOOL_STOP_AFTER):
-                    _tool_stop_injected = True
+                    self._tool_stop_injected = True
                     _stop_suffix = os.environ.get("DRYDOCK_STOP_NOW_SUFFIX", "")
                     self._inject_system_note(
                         f"You have used {tool_turns} tool calls. "
@@ -999,7 +1003,7 @@ class AgentLoop:
                         + (f" {_stop_suffix}" if _stop_suffix else "")
                     )
                 elif (TOOL_STOP_AFTER > 0
-                        and _tool_stop_injected
+                        and self._tool_stop_injected
                         and tool_turns > TOOL_STOP_AFTER):
                     # Model called another tool after the stop note — force
                     # text-only on the next LLM call so it must emit an answer.
@@ -1456,7 +1460,7 @@ class AgentLoop:
                 and bool(_prev_tool_result.strip())
             )
             if _stall_attempt == 0:
-                if _tool_stop_injected:
+                if self._tool_stop_injected:
                     _fa_suffix = os.environ.get(
                         "DRYDOCK_STOP_NOW_SUFFIX",
                         "End with 'FINAL ANSWER: <answer>'.",
@@ -1535,7 +1539,7 @@ class AgentLoop:
                         + (f" {_generic_suffix}" if _generic_suffix else "")
                     )
             elif _stall_attempt == 1:
-                if _tool_stop_injected:
+                if self._tool_stop_injected:
                     _fa_suffix = os.environ.get(
                         "DRYDOCK_STOP_NOW_SUFFIX",
                         "End with 'FINAL ANSWER: <answer>'.",
@@ -1591,7 +1595,7 @@ class AgentLoop:
                         + (f" {_generic_suffix}" if _generic_suffix else "")
                     )
             else:
-                if _tool_stop_injected:
+                if self._tool_stop_injected:
                     _fa_suffix = os.environ.get(
                         "DRYDOCK_STOP_NOW_SUFFIX",
                         "End with 'FINAL ANSWER: <answer>'.",
@@ -1658,7 +1662,7 @@ class AgentLoop:
             # (cleared) at the previous LLM call boundary, so without
             # this the stall-retry call gets tool_choice="auto" and the
             # model loops back to calling tools instead of answering.
-            if _tool_stop_injected:
+            if self._tool_stop_injected:
                 self._hle_force_text_only = True
             # Loop back to re-call the LLM.
             continue
@@ -4439,6 +4443,11 @@ or replace freely; future sessions will respect your edits._
     def _reset_session(self) -> None:
         self.session_id = str(uuid4())
         self.session_logger.reset_session(self.session_id)
+        # Defensive init — _perform_llm_turn reads this in 4 places;
+        # if a code path calls into the LLM turn before
+        # _conversation_loop sets the local, we'd hit NameError.
+        # Observed in user TUI 2026-05-18.
+        self._tool_stop_injected = False
 
     def set_approval_callback(self, callback: ApprovalCallback) -> None:
         self.approval_callback = callback
@@ -4636,6 +4645,12 @@ or replace freely; future sessions will respect your edits._
         # /compact since the goal is session-scoped and a fresh session
         # shouldn't inherit the prior pursuit.
         self.goal = None
+        # Defensive init for _tool_stop_injected — _perform_llm_turn
+        # references this at multiple sites; if a session-level reset
+        # path calls into the LLM turn before _conversation_loop's
+        # init line, we'd hit NameError. Observed in user's actual TUI
+        # 2026-05-18 with the slides project.
+        self._tool_stop_injected = False
 
     async def compact(self) -> str:
         try:

{drydock_cli-2.8.59 → drydock_cli-2.8.61}/pyproject.toml

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

{drydock_cli-2.8.59 → drydock_cli-2.8.61}/scripts/llm_balancer.py

@@ -22,6 +22,7 @@ import http.server
 import socket
 import sys
 import threading
+import urllib.error
 import urllib.request
 
 BACKENDS = [
@@ -86,12 +87,34 @@ class ProxyHandler(http.server.BaseHTTPRequestHandler):
                 return
         except _CLIENT_DROP_ERRORS:
             return  # client gave up, no need to failover
+        except urllib.error.HTTPError as http_err:
+            # Backend returned a valid HTTP error (4xx/5xx). Forward the
+            # original response body so drydock can parse the detailed error
+            # message (e.g. "Failed to parse tool call arguments as JSON:
+            # missing closing quote"). Failovering to an identical backend
+            # would return the same error and strips the body, breaking
+            # drydock's bad-tool-call recovery.
+            try:
+                err_body = http_err.read()
+                self.send_response(http_err.code)
+                for key, val in http_err.headers.items():
+                    if key.lower() not in ('transfer-encoding', 'connection'):
+                        self.send_header(key, val)
+                self.end_headers()
+                self.wfile.write(err_body)
+            except _CLIENT_DROP_ERRORS:
+                pass
+            except Exception:
+                _safe_send_error(self, http_err.code, str(http_err))
+            return
         except Exception as e:
             primary_err = e
 
-        # Failover: try the next backend in rotation. (Was hardcoded to
-        # `1 - idx` which only works for 2-backend pools; with 3+ pool
-        # entries that became BACKENDS[-1] = same backend at idx 2 → loop.)
+        # Failover: try the next backend in rotation. Only reached for true
+        # network errors (connection refused, timeout) — not HTTP 4xx/5xx.
+        # (Was hardcoded to `1 - idx` which only works for 2-backend pools;
+        # with 3+ pool entries that became BACKENDS[-1] = same backend at
+        # idx 2 → loop.)
         other = BACKENDS[(idx + 1) % len(BACKENDS)]
         url = f"{other}{self.path}"
         req = urllib.request.Request(url, data=body, method='POST')
@@ -105,6 +128,19 @@ class ProxyHandler(http.server.BaseHTTPRequestHandler):
                         self.send_header(key, val)
                 self.end_headers()
                 self.wfile.write(data)
+        except urllib.error.HTTPError as http_err2:
+            try:
+                err_body = http_err2.read()
+                self.send_response(http_err2.code)
+                for key, val in http_err2.headers.items():
+                    if key.lower() not in ('transfer-encoding', 'connection'):
+                        self.send_header(key, val)
+                self.end_headers()
+                self.wfile.write(err_body)
+            except _CLIENT_DROP_ERRORS:
+                pass
+            except Exception:
+                _safe_send_error(self, http_err2.code, str(http_err2))
         except _CLIENT_DROP_ERRORS:
             return
         except Exception as e2:

drydock_cli-2.8.61/tests/test_tool_stop_injected_scope.py

@@ -0,0 +1,58 @@
+"""Regression test for the NameError that crashed real user TUI sessions.
+
+Bug observed 2026-05-18: user typing into drydock TUI got
+`Error: name '_tool_stop_injected' is not defined` because
+`_perform_llm_turn` referenced `_tool_stop_injected` as if it were
+a closure variable from `_conversation_loop`, but it's actually a
+local variable in a different method's scope. Python NameError when
+the read site fired.
+
+Fix: promote to `self._tool_stop_injected` so both methods see it,
+with defensive init in `_reset_session`.
+"""
+from __future__ import annotations
+
+import inspect
+
+from drydock.core.agent_loop import AgentLoop
+
+
+def test_perform_llm_turn_uses_self_for_tool_stop_injected():
+    """All references inside _perform_llm_turn must use `self.` —
+    bare `_tool_stop_injected` would NameError because that name
+    is bound in `_conversation_loop`, a different method's scope."""
+    src = inspect.getsource(AgentLoop._perform_llm_turn)
+    bare_refs = src.count("_tool_stop_injected")
+    self_refs = src.count("self._tool_stop_injected")
+    assert bare_refs > 0, "expected _tool_stop_injected references in _perform_llm_turn"
+    assert bare_refs == self_refs, (
+        f"_perform_llm_turn has {bare_refs} _tool_stop_injected refs "
+        f"but only {self_refs} are self.-prefixed — would NameError on the rest"
+    )
+
+
+def test_conversation_loop_writes_self_tool_stop_injected():
+    """_conversation_loop should also use the self. attribute (both for
+    initialization at the top of the prompt and for read/write inside
+    the loop body), so the value persists across method boundaries."""
+    src = inspect.getsource(AgentLoop._conversation_loop)
+    # The init line should set self._tool_stop_injected (not bare local)
+    assert "self._tool_stop_injected = False" in src, (
+        "_conversation_loop must init self._tool_stop_injected"
+    )
+    # Any remaining bare reference would be a footgun for future refactors
+    # (someone moves a block out and hits NameError).
+    bare = src.count("_tool_stop_injected") - src.count("self._tool_stop_injected")
+    # The comment line "# Promoted to self._tool_stop_injected" contains
+    # the substring once without `self.` prefix; allow that one.
+    assert bare <= 1, f"unexpected {bare} bare _tool_stop_injected refs in _conversation_loop"
+
+
+def test_reset_session_initializes_tool_stop_injected():
+    """Defensive init in _reset_session prevents NameError if
+    _perform_llm_turn is ever called before _conversation_loop's
+    own init line (e.g. via a session-resume code path)."""
+    src = inspect.getsource(AgentLoop._reset_session)
+    assert "_tool_stop_injected" in src, (
+        "_reset_session must initialize self._tool_stop_injected"
+    )