drydock-cli 2.6.80__tar.gz → 2.6.82__tar.gz

drydock_cli-2.6.82/.auto_release.lock

@@ -0,0 +1 @@
+1419074

{drydock_cli-2.6.80 → drydock_cli-2.6.82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.6.80
+Version: 2.6.82
 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.6.80 → drydock_cli-2.6.82}/drydock/cli/textual_ui/handlers/event_handler.py

@@ -84,7 +84,16 @@ class EventHandler:
                     )
                 await self._handle_assistant_message(event)
             case ToolCallEvent():
-                await self.finalize_streaming()
+                # Finalize assistant content stream (user-visible text) but
+                # KEEP the reasoning widget open across tool calls. Closing
+                # it spawns a fresh "Thought" widget for every reasoning
+                # chunk between calls — a turn with N tool calls shows N
+                # "Thought" widgets stacked down the screen.
+                if self.current_streaming_message is not None:
+                    await self.current_streaming_message.stop_stream()
+                    if self.current_streaming_message.is_stripped_content_empty():
+                        await self.current_streaming_message.remove()
+                    self.current_streaming_message = None
                 return await self._handle_tool_call(event, loading_widget)
             case ToolResultEvent():
                 await self.finalize_streaming()

{drydock_cli-2.6.80 → drydock_cli-2.6.82}/drydock/core/llm/format.py

@@ -76,22 +76,52 @@ class APIToolFormatHandler:
         return "auto"
 
     def process_api_response_message(self, message: Any) -> LLMMessage:
-        # Strip ALL Gemma 4 leaked channel tokens from content.
+        # Strip ALL Gemma 4 leaked channel/tool-call tokens from content.
         # The model emits various formats:
         #   <|channel>thought...<channel|>  (thinking tokens)
         #   <|channel>call:tool_name{...}<tool_call|>  (malformed tool calls)
         #   <|channel><|channel>list_mcp_resources{...}<tool_call|>  (double channel)
-        # Keeping them wastes context and confuses subsequent turns.
+        #   <|tool_call>call:write_file{content:<|"|>import ...  (bare tool_call,
+        #       observed in color_converter session 20260414_121725 after a
+        #       syntax-thrash BLOCK — model panicked, emitted this as its FINAL
+        #       assistant turn with no real tool call; shakedown interpreted the
+        #       text-only response as completion and ended the session.)
+        # Keeping them wastes context, confuses subsequent turns, and can
+        # fake-signal "done" to harnesses that watch for text-only messages.
         content = message.content
-        if content and "<|channel>" in content:
+        if content and ("<|channel>" in content or "<|tool_call>" in content):
             import re as _re
-            # Strip any <|channel>...<channel|> or <|channel>...<tool_call|> blocks
+            # Strip <|channel>...<channel|> or <|channel>...<tool_call|> blocks
             content = _re.sub(
                 r"<\|channel\>.*?(?:<channel\|>|<tool_call\|>)",
                 "",
                 content,
                 flags=_re.DOTALL,
-            ).strip() or None
+            )
+            # Strip bare <|tool_call>call:...<tool_call|> blocks (no channel
+            # prefix). Unterminated variants (stream cut off mid-emission)
+            # are stripped by the catch-all below.
+            content = _re.sub(
+                r"<\|tool_call\>.*?<tool_call\|>",
+                "",
+                content,
+                flags=_re.DOTALL,
+            )
+            # Final catch-all: any dangling <|...|> or <...|> tokens that
+            # didn't form a complete pair (stream truncation).
+            content = _re.sub(r"<\|[^>]{0,200}\|>", "", content)
+            content = _re.sub(r"<\|[^>]{0,200}>", "", content)
+            content = _re.sub(r"<[^>]{0,200}\|>", "", content)
+            # If remaining content is just tool-call-leak residue (starts
+            # with `call:toolname{` after stripping), nuke it. Otherwise
+            # harness watchers treat the garbage text as a completion
+            # signal. agent_loop's empty-content nudge will ask the model
+            # to continue with a real tool call.
+            stripped = content.strip()
+            if _re.match(r"^(call:\w+\{|\w+\{content:)", stripped):
+                content = None
+            else:
+                content = stripped or None
 
         clean_message = {
             "role": message.role,
@@ -134,25 +164,52 @@ class APIToolFormatHandler:
             try:
                 args = json.loads(raw_json)
             except json.JSONDecodeError:
-                # Don't silently use {} — log the malformed args and skip
+                # Gemma 4 frequently leaks thinking-token markers INSIDE
+                # JSON string values. Tokens like "<|\Fix" make `\F` an
+                # invalid JSON escape, which crashes the decoder and loses
+                # the whole tool call. Sanitize and retry before giving up.
                 import logging
+                import re as _re
                 logging.getLogger(__name__).warning(
                     "Malformed tool call JSON for %s: %s",
                     function_call.name,
                     (function_call.arguments or "")[:200],
                 )
-                # Try to salvage partial JSON by closing brackets
                 raw = (function_call.arguments or "").strip()
+                args = {}
                 if raw:
-                    # Count open/close braces and try to fix
-                    opens = raw.count('{') - raw.count('}')
-                    raw_fixed = raw + '}' * max(0, opens)
+                    sanitized = raw
+                    # Strip complete <|channel>...<channel|>/<tool_call|> blocks
+                    sanitized = _re.sub(
+                        r"<\|channel\>.*?(?:<channel\|>|<tool_call\|>)",
+                        "", sanitized, flags=_re.DOTALL,
+                    )
+                    sanitized = _re.sub(
+                        r"<\|tool_call\>.*?<tool_call\|>",
+                        "", sanitized, flags=_re.DOTALL,
+                    )
+                    # Strip unpaired/truncated <|...|> and <|...> tokens.
+                    sanitized = _re.sub(r"<\|[^>]{0,200}\|>", "", sanitized)
+                    sanitized = _re.sub(r"<\|[^>]{0,200}>", "", sanitized)
+                    sanitized = _re.sub(r"<[^>]{0,200}\|>", "", sanitized)
+                    # Escape any remaining invalid backslash escapes (JSON
+                    # only allows \" \\ \/ \b \f \n \r \t \u). Catches e.g.
+                    # `<|\Fix` residue where `\F` would abort the decoder.
+                    sanitized = _re.sub(
+                        r'\\(?!["\\/bfnrtu])', r'\\\\', sanitized,
+                    )
                     try:
-                        args = json.loads(raw_fixed)
+                        args = json.loads(sanitized)
                     except json.JSONDecodeError:
-                        args = {"_parse_error": f"Malformed JSON: {raw[:100]}..."}
-                else:
-                    args = {}
+                        # Last-ditch: try closing any unbalanced braces.
+                        opens = sanitized.count("{") - sanitized.count("}")
+                        if opens > 0:
+                            try:
+                                args = json.loads(sanitized + "}" * opens)
+                            except json.JSONDecodeError:
+                                args = {"_parse_error": f"Malformed JSON after sanitize: {sanitized[:100]}..."}
+                        else:
+                            args = {"_parse_error": f"Malformed JSON: {raw[:100]}..."}
 
             tool_calls.append(
                 ParsedToolCall(

{drydock_cli-2.6.80 → drydock_cli-2.6.82}/drydock/core/tools/builtins/bash.py

@@ -388,30 +388,17 @@ class Bash(
 
             returncode = proc.returncode or 0
 
-            # Mechanical loop-breaker.
-            # Tier 1 (3rd identical call): collapse body to short notice.
-            # Tier 2 (5th identical call): raise ToolError. Notice-in-
-            # tool-result was being ignored 75/75 times by Gemma 4
-            # (session 20260414_003629 had 99 bash calls, 75 were NOTICE
-            # re-runs). ToolError goes through the error-handling path
-            # and the model visibly reacts to those.
+            # Mechanical loop-breaker (ADVISORY ONLY — never raise
+            # ToolError; see feedback_no_tool_errors_for_loop_detection.md).
+            # 3rd+ identical call: collapse body to short notice so the
+            # model sees "this ran already with same output" without
+            # getting refused into a block-loop.
             state = self.state.__dict__.setdefault("_bash_history", {})
             combined = stdout + "\n---STDERR---\n" + stderr
             out_hash = hash((combined, returncode))
             entry = state.get(args.command)
             if entry and entry["hash"] == out_hash:
                 entry["count"] += 1
-                if entry["count"] >= 5:
-                    raise ToolError(
-                        f"REFUSED: `{args.command[:80]}` has run "
-                        f"{entry['count']} times with IDENTICAL output "
-                        f"(rc={returncode}). Re-running will NOT change "
-                        f"anything. You MUST do something DIFFERENT: "
-                        f"edit source files, write tests, read a DIFFERENT "
-                        f"file, or move on. This exact command is blocked "
-                        f"until you take a different action. Last stdout "
-                        f"(first 300): {stdout[:300]!r}"
-                    )
                 if entry["count"] >= 3:
                     notice = (
                         f"[NOTICE: this is the #{entry['count']} identical "

{drydock_cli-2.6.80 → drydock_cli-2.6.82}/drydock/core/tools/builtins/write_file.py

@@ -392,44 +392,19 @@ class WriteFile(
     ) -> AsyncGenerator[ToolStreamEvent | WriteFileResult, None]:
         file_path, file_existed, content_bytes = self._prepare_and_validate_path(args)
 
-        # Path-write thrash gate (catches write_file ↔ search_replace ping-pong).
-        # Counts CUMULATIVE writes to a path regardless of content. Identical-
-        # content dedup misses this case because an intervening search_replace
-        # mutates the file between writes, so each write_file sees "different"
-        # content even though the model is rewriting the same broken version.
-        # Real bug: minivc session wrote commands/__init__.py 11 times — every
-        # write was clobbering the prior search_replace fix. Threshold 5 is
-        # generous; legitimate work writes a file 1–2x.
+        # Path-write thrash counter (just counts; advisory only). Per
+        # feedback_no_tool_errors_for_loop_detection.md: loop detection
+        # in tools must be advisory, never raise ToolError — hard blocks
+        # cause their own loops on long tasks.
         path_writes = self.state.__dict__.setdefault("_path_writes", {})
         path_key = str(file_path)
         path_writes[path_key] = path_writes.get(path_key, 0) + 1
         path_n = path_writes[path_key]
-        if path_n >= 5:
-            raise ToolError(
-                f"BLOCKED: write_file({file_path.name}) has been called "
-                f"{path_n} times this session on the same path. This is "
-                f"a thrash loop — likely write_file overwriting prior "
-                f"search_replace fixes, or repeated full rewrites instead "
-                f"of targeted edits. Refused. Switch tactic: "
-                f"(1) read_file({file_path.name}) to see CURRENT disk state, "
-                f"(2) use search_replace for surgical fixes, "
-                f"(3) move to a DIFFERENT file in your plan and come back later. "
-                f"Do NOT call write_file on this path again until you have "
-                f"made progress elsewhere."
-            )
 
         # Skip if file already has identical content (prevents write loops).
-        #
-        # Three-tier escalation — first call is a friendly advisory, second
-        # adds concrete state, third is a HARD BLOCK via ToolError. Every
-        # advisory signal in drydock (dedup content, system note nudge,
-        # missing-import warning, user-typed STOP interrupt) is ignored by
-        # Gemma 4 on write loops — confirmed by 3 of 5 failures in the
-        # April 2026 user-pain suite run. The hard block is narrow: it only
-        # fires on pure no-op writes (file exists AND content matches disk)
-        # after 3 identical attempts. Legitimate retries (different content,
-        # different path, or after the model successfully wrote a DIFFERENT
-        # file) are never blocked.
+        # ADVISORY ONLY — must never raise ToolError. See
+        # feedback_no_tool_errors_for_loop_detection.md: hard blocks cause
+        # their own loops on long tasks.
         if file_existed:
             try:
                 existing = file_path.read_text(encoding="utf-8")
@@ -439,28 +414,6 @@ class WriteFile(
                     state[key] = state.get(key, 0) + 1
                     repeat_n = state[key]
 
-                    # Tier 3: hard block. 3rd identical no-op write → ToolError.
-                    if repeat_n >= 3:
-                        try:
-                            siblings = sorted(
-                                p.name for p in file_path.parent.iterdir()
-                                if p.is_file() and not p.name.startswith("__pycache__")
-                            )
-                            sibling_str = ", ".join(siblings) if siblings else "(none)"
-                        except Exception:
-                            sibling_str = "(unknown)"
-                        raise ToolError(
-                            f"BLOCKED: write_file({file_path.name}) has been called "
-                            f"{repeat_n} times with IDENTICAL content that already "
-                            f"matches the file on disk. This is a no-op loop. "
-                            f"Files in {file_path.parent.name}/: {sibling_str}. "
-                            f"Do something DIFFERENT — write a different file from "
-                            f"your plan, or run bash with `python3 -m "
-                            f"{file_path.parent.name} --help` to verify the package. "
-                            f"This exact write_file call is refused."
-                        )
-
-                    # Tier 2: escalated advisory with directory listing.
                     msg = "File already has this exact content (no-op). "
                     if repeat_n >= 2:
                         try:
@@ -472,16 +425,13 @@ class WriteFile(
                             msg += (
                                 f"You've written this exact file {repeat_n} times. "
                                 f"Files currently in {file_path.parent.name}/: "
-                                f"{sibling_str}. STOP writing this file. "
-                                f"Either write a DIFFERENT file from your plan, "
-                                f"or run `bash` with `python3 -m {file_path.parent.name} --help` "
-                                f"to verify the package works. "
-                                f"ONE MORE identical write to this path will be blocked."
+                                f"{sibling_str}. Move on — write a DIFFERENT file "
+                                f"from your plan, or run `bash` with `python3 -m "
+                                f"{file_path.parent.name} --help` to verify."
                             )
                         except Exception:
                             msg += "Move to the NEXT file in your plan."
                     else:
-                        # Tier 1: first duplicate — friendly advisory.
                         msg += "Move to the NEXT file in your plan."
 
                     yield WriteFileResult(
@@ -491,8 +441,6 @@ class WriteFile(
                         content=msg,
                     )
                     return
-            except ToolError:
-                raise
             except Exception:
                 pass
 
@@ -511,10 +459,9 @@ class WriteFile(
                 import ast
                 tree = ast.parse(args.content)
             except SyntaxError as e:
-                # Track consecutive syntax-error writes per file. Gemma 4
-                # thrashes — each retry has DIFFERENT (still broken) content,
-                # so identical-content dedup never fires. After 3 in a row on
-                # the same path, escalate to ToolError forcing a tactic change.
+                # Track consecutive syntax-error writes per file. ADVISORY
+                # ONLY — must not raise ToolError. See
+                # feedback_no_tool_errors_for_loop_detection.md.
                 thrash = self.state.__dict__.setdefault("_syntax_thrash", {})
                 key = str(file_path)
                 thrash[key] = thrash.get(key, 0) + 1
@@ -525,21 +472,17 @@ class WriteFile(
                     f"\n  Fix this before moving to the next file."
                 )
                 if thrash_n >= 3:
-                    raise ToolError(
-                        f"BLOCKED: write_file({file_path.name}) has produced "
-                        f"{thrash_n} consecutive syntax errors on this file. "
-                        f"Current error: line {e.lineno}: {e.msg}. "
-                        f"Rewriting the whole file with broken syntax again is "
-                        f"refused. Switch tactic: "
-                        f"(1) read_file({file_path.name}) to see current state, "
-                        f"(2) use search_replace for targeted fixes, or "
-                        f"(3) write a DIFFERENT file from your plan and come "
-                        f"back to this one. This exact write is rejected."
+                    syntax_warning += (
+                        f"\n  [{thrash_n}th consecutive syntax error on this "
+                        f"file. Switch tactic: read_file() to see current "
+                        f"state, then use search_replace for surgical fixes, "
+                        f"or write a DIFFERENT file and come back later.]"
                     )
                 elif thrash_n == 2:
                     syntax_warning += (
-                        f"\n  [2nd syntax error on this file. ONE MORE will be "
-                        f"blocked — switch to search_replace or read the file first.]"
+                        f"\n  [2nd syntax error on this file — consider "
+                        f"read_file + search_replace instead of another full "
+                        f"rewrite.]"
                     )
             else:
                 # Reset thrash counter on a successful parse.

{drydock_cli-2.6.80 → drydock_cli-2.6.82}/drydock/core/tools/manager.py

@@ -180,6 +180,27 @@ class ToolManager:
             name: cls for name, cls in self._available.items() if cls.is_available()
         }
 
+        # Auto-disable tools that misfire for Gemma 4. The model mixes up
+        # `task` (subagent delegation) with `todo` (task list), recurses
+        # with thinking-token-leaked output that gets fed back to itself.
+        # Observed: minivc session 20260414_120752 — model called `task`
+        # with builder agent; subagent response was raw <|tool_call>
+        # thinking tokens rendered as text, triggered session hang.
+        # Scaffolding per CLAUDE.md constraint; remove when model improves.
+        _GEMMA4_AUTO_DISABLE = {
+            "task", "task_create", "task_update", "task_list",
+            "ask_user_question", "invoke_skill", "tool_search",
+        }
+        try:
+            active = self._config.get_active_model()
+            if "gemma" in active.name.lower():
+                runtime_available = {
+                    name: cls for name, cls in runtime_available.items()
+                    if name not in _GEMMA4_AUTO_DISABLE
+                }
+        except (ValueError, AttributeError):
+            pass
+
         if self._config.enabled_tools:
             return {
                 name: cls

{drydock_cli-2.6.80 → drydock_cli-2.6.82}/pyproject.toml

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

drydock_cli-2.6.80/.auto_release.lock

@@ -1 +0,0 @@
-1337772