drydock-cli 2.6.86__tar.gz → 2.6.88__tar.gz

drydock_cli-2.6.88/.auto_release.lock

@@ -0,0 +1 @@
+1473078

{drydock_cli-2.6.86 → drydock_cli-2.6.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.6.86
+Version: 2.6.88
 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.86 → drydock_cli-2.6.88}/drydock/core/agent_loop.py

@@ -1913,6 +1913,46 @@ class AgentLoop:
             and all(s == sigs[-1] for s in sigs[-REPEAT_FORCE_STOP_THRESHOLD:])
         ):
             return "FORCE_STOP"
+
+        # Check 1b: Small-variant oscillation. Recent calls bounce among
+        # 2-3 distinct signatures on the same path — e.g. write_file(X)
+        # ↔ search_replace(X) ping-pong, or alternating between V1 and
+        # V2 of the same file. Max exact-consecutive hits 2-3 so Check 1
+        # misses, but user perceives a stuck loop. Observed 2026-04-15
+        # stress session 20260415_025053 at prompt 24 (json_set_tool.py).
+        if len(sigs) >= 12:
+            recent_12 = sigs[-12:]
+            unique = set(recent_12)
+            # Tiny variant set (≤3) + high overlap = oscillation
+            if len(unique) <= 3:
+                # Also require that the model is stuck on a SINGLE path
+                # for the bulk of these calls, so we don't false-fire on
+                # legitimate "grep then read then edit then grep again"
+                # flows that use different paths.
+                paths: list[str] = []
+                for msg in list(reversed(self.messages))[:40]:
+                    if msg.role == Role.assistant and msg.tool_calls:
+                        for tc in msg.tool_calls:
+                            if not tc.function:
+                                continue
+                            try:
+                                a = json.loads(tc.function.arguments or "{}")
+                            except (json.JSONDecodeError, AttributeError):
+                                continue
+                            p = a.get("file_path") or a.get("path") or ""
+                            if p:
+                                paths.append(p)
+                            if len(paths) >= 12:
+                                break
+                        if len(paths) >= 12:
+                            break
+                last_12_paths = paths[:12]
+                if last_12_paths:
+                    # If one path accounts for >=75% of recent calls → oscillation
+                    most = max(set(last_12_paths), key=last_12_paths.count)
+                    if last_12_paths.count(most) >= 9:
+                        return "FORCE_STOP"
+
         if (
             len(sigs) >= REPEAT_WARNING_THRESHOLD
             and all(s == sigs[-1] for s in sigs[-REPEAT_WARNING_THRESHOLD:])

{drydock_cli-2.6.86 → drydock_cli-2.6.88}/drydock/core/llm/format.py

@@ -47,7 +47,7 @@ def safe_parse_tool_args(raw_json: str | None, tool_name: str = "?") -> dict[str
     if not raw:
         return {}
     try:
-        return json.loads(raw)
+        return _clean_string_values(json.loads(raw))
     except json.JSONDecodeError:
         pass
 
@@ -68,17 +68,66 @@ def safe_parse_tool_args(raw_json: str | None, tool_name: str = "?") -> dict[str
     sanitized = _re.sub(r"<[^>]{0,200}\|>", "", sanitized)
     sanitized = _re.sub(r'\\(?!["\\/bfnrtu])', r"\\\\", sanitized)
 
+    parsed: dict | None = None
     try:
-        return json.loads(sanitized)
+        parsed = json.loads(sanitized)
     except json.JSONDecodeError:
-        pass
-    opens = sanitized.count("{") - sanitized.count("}")
-    if opens > 0:
-        try:
-            return json.loads(sanitized + "}" * opens)
-        except json.JSONDecodeError:
-            pass
-    return {"_parse_error": f"Malformed JSON: {raw[:100]}..."}
+        opens = sanitized.count("{") - sanitized.count("}")
+        if opens > 0:
+            try:
+                parsed = json.loads(sanitized + "}" * opens)
+            except json.JSONDecodeError:
+                pass
+    if parsed is None:
+        return {"_parse_error": f"Malformed JSON: {raw[:100]}..."}
+    return _clean_string_values(parsed)
+
+
+def _clean_string_values(obj: Any, field_name: str = "") -> Any:
+    r"""Walk a JSON-decoded structure and clean leaked-token residue from
+    string values. After json.loads, a tool-arg path like
+    `"tool\\_agent/parser.\\py<|\"|>"` becomes the literal Python string
+    `tool\_agent/parser.\py<|"|>` — preserves the corruption. Tool
+    validation then rejects it and the model retries the same broken
+    path forever.
+
+    Observed 2026-04-15 stress session 20260415_041558: 40+ write_file
+    calls to `"tool\_agent/parser.\py"<|"|>` in an attractor loop with
+    8 distinct signatures (dodging both exact-repeat and 3-variant
+    oscillation detectors).
+
+    Cleaning depth depends on the field name (outer JSON key):
+
+    * path-like keys (`path`, `file_path`, `file`, `command`, `cwd`,
+      `url`) — aggressive: strip `<|...|>` tokens AND drop orphan
+      backslashes before letters (paths should never contain those).
+    * content-like keys (`content`, `new_string`, `old_string`,
+      `text`, `body`, `description`) — conservative: only strip
+      `<|...|>` tokens; preserve `\d` / `\w` / `\n` / `\t` etc. which
+      are legitimate in source code, regex patterns, etc.
+    * everything else — conservative.
+    """
+    import re as _re
+    PATH_LIKE = {"path", "file_path", "file", "command", "cwd", "url"}
+    if isinstance(obj, dict):
+        return {k: _clean_string_values(v, field_name=k) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_clean_string_values(v, field_name=field_name) for v in obj]
+    if isinstance(obj, str):
+        s = obj
+        # Always strip leaked channel/tool_call tokens — never legit content.
+        s = _re.sub(r"<\|channel\>.*?(?:<channel\|>|<tool_call\|>)", "", s, flags=_re.DOTALL)
+        s = _re.sub(r"<\|tool_call\>.*?<tool_call\|>", "", s, flags=_re.DOTALL)
+        s = _re.sub(r"<\|[^>]{0,200}\|>", "", s)
+        s = _re.sub(r"<\|[^>]{0,200}>", "", s)
+        s = _re.sub(r"<[^>]{0,200}\|>", "", s)
+        if field_name in PATH_LIKE:
+            # Drop orphan backslashes before letters only on path-like
+            # fields. Real paths never have `\d` or `\p`. Model emits
+            # these as over-escaped JSON; this normalizes them.
+            s = _re.sub(r"\\(?=[A-Za-z_])", "", s)
+        return s
+    return obj
 
 
 class ParsedToolCall(BaseModel):

{drydock_cli-2.6.86 → drydock_cli-2.6.88}/pyproject.toml

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

drydock_cli-2.6.86/.auto_release.lock

@@ -1 +0,0 @@
-1454502