drydock-cli 2.9.69__tar.gz → 2.9.71__tar.gz

{drydock_cli-2.9.69 → drydock_cli-2.9.71}/PKG-INFO

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

@@ -1503,32 +1503,77 @@ class AgentLoop:
                                 logger.debug("bad-tool-call drop failed: %s", drop_err)
 
                         try:
-                            # First try: truncate old messages
-                            for i, msg in enumerate(self.messages):
-                                if i >= len(self.messages) - 4:
-                                    break
-                                if msg.role == Role.tool and hasattr(msg, 'content'):
-                                    content = str(msg.content) if msg.content else ""
-                                    if len(content) > 200:
-                                        msg.content = content[:100] + "\n[truncated]"
-                                elif msg.role == Role.assistant and hasattr(msg, 'content'):
-                                    content = str(msg.content) if msg.content else ""
-                                    if len(content) > 500:
-                                        msg.content = content[:200] + "\n[truncated]"
-
-                            # Second try: if messages > 20, keep only last 6
-                            if len(self.messages) > 20:
+                            # 2026-06-05: track API-error count for self-/clear
+                            # escalation. Operator: 20-file rename task hit API
+                            # error so bad that only manual /clear could recover.
+                            self._api_error_session_count = (
+                                getattr(self, "_api_error_session_count", 0) + 1
+                            )
+                            # SELF-CLEAR: 2nd+ API error in this session ⇒
+                            # do what the operator would have done manually.
+                            # Keep system msg + original user task ONLY,
+                            # inject a restart note. Everything else dropped.
+                            if self._api_error_session_count >= 2:
+                                kept = []
+                                # messages[0] = system
+                                if len(self.messages) > 0:
+                                    kept.append(self.messages[0])
+                                # First user message = original task
                                 first_user = None
                                 for msg in self.messages:
-                                    if msg.role == Role.user:
+                                    if msg.role == Role.user and not (
+                                        (msg.content or "").startswith("[Drydock")
+                                    ):
                                         first_user = msg
                                         break
-                                kept = []
                                 if first_user:
                                     kept.append(first_user)
-                                kept.extend(self.messages[-5:])
+                                kept.append(LLMMessage(
+                                    role=Role.user,
+                                    content=(
+                                        "[Drydock self-/clear] Previous attempts "
+                                        "hit repeated API errors and got pruned. "
+                                        "Re-read the task above. Take a SIMPLER "
+                                        "approach: for multi-file edits use "
+                                        "`mechanical_rename` if applicable, "
+                                        "otherwise do ONE file at a time with "
+                                        "small write_file payloads."
+                                    ),
+                                ))
                                 self.messages.reset(kept)
-                                logger.info("Emergency reset: kept first user + last 5 messages")
+                                self._api_error_session_count = 0
+                                logger.warning(
+                                    "[SELF-CLEAR] auto-recovered from repeated "
+                                    "API errors — kept system + first user + "
+                                    "restart note (%d msgs total)", len(kept),
+                                )
+                            else:
+                                # First try: truncate old messages
+                                for i, msg in enumerate(self.messages):
+                                    if i >= len(self.messages) - 4:
+                                        break
+                                    if msg.role == Role.tool and hasattr(msg, 'content'):
+                                        content = str(msg.content) if msg.content else ""
+                                        if len(content) > 200:
+                                            msg.content = content[:100] + "\n[truncated]"
+                                    elif msg.role == Role.assistant and hasattr(msg, 'content'):
+                                        content = str(msg.content) if msg.content else ""
+                                        if len(content) > 500:
+                                            msg.content = content[:200] + "\n[truncated]"
+
+                                # Second try: if messages > 20, keep only last 6
+                                if len(self.messages) > 20:
+                                    first_user = None
+                                    for msg in self.messages:
+                                        if msg.role == Role.user:
+                                            first_user = msg
+                                            break
+                                    kept = []
+                                    if first_user:
+                                        kept.append(first_user)
+                                    kept.extend(self.messages[-5:])
+                                    self.messages.reset(kept)
+                                    logger.info("Emergency reset: kept first user + last 5 messages")
                         except Exception:
                             pass
                         if dropped_bad_tool_call:
@@ -2622,6 +2667,100 @@ class AgentLoop:
             )
         return None
 
+    def _maybe_perform_loop_surgery(self, tool_call: ResolvedToolCall) -> None:
+        """Detect tool-call loops and rewrite history to break them.
+
+        Theory: the model gets locked into a loop because the bloated
+        context (3+ same call + 3+ same error result) keeps reinforcing
+        the pattern. Each nudge ADDS to the locked-in context. Real fix:
+        SHORTEN the context — remove the loop residue, keep only what's
+        useful, inject a fresh marker so the model "starts over."
+
+        Triggers when:
+          1. This tool signature has been called 3+ times AND
+          2. Last surgery was >= 6 messages ago (avoid surgery spam)
+
+        Surgery:
+          - Keep messages[0] (system) and messages[1] (original user task)
+          - Keep last 3 productive (non-error) tool result pairs
+          - Drop everything else
+          - Inject a system note: "Looping detected — context reset."
+        """
+        args_str = json.dumps(tool_call.args_dict, sort_keys=True, default=str)
+        sig = hashlib.sha256(
+            f"{tool_call.tool_name}:{args_str}".encode()
+        ).hexdigest()
+        count = self._tool_call_history.get(sig, (0, ""))[0]
+        if count < 3:
+            return
+        last_surgery_idx = getattr(self, "_last_loop_surgery_idx", -10)
+        if len(self.messages) - last_surgery_idx < 6:
+            return  # already cleaned recently, give it time
+        # Identify "productive" tool results = those without <tool_error>,
+        # 'Skipped:', 'NO `path`', 'REPEATED READ', etc.
+        bad_markers = (
+            "<tool_error>", "Skipped:", "NO `path`", "NO path supplied",
+            "REPEATED READ", "2nd identical", "BLOCKED:", "HARD-BLOCK",
+            "PREMATURE EXIT",
+        )
+        productive_pairs: list[tuple[int, int]] = []  # (assistant_idx, tool_idx)
+        i = 0
+        while i < len(self.messages) - 1:
+            m = self.messages[i]
+            if m.role == Role.assistant and m.tool_calls:
+                # Find paired tool result(s)
+                j = i + 1
+                pair_good = True
+                while j < len(self.messages) and self.messages[j].role == Role.tool:
+                    content = self.messages[j].content or ""
+                    if any(b in content for b in bad_markers):
+                        pair_good = False
+                        break
+                    j += 1
+                if pair_good and j > i + 1:
+                    productive_pairs.append((i, j - 1))
+                i = j
+            else:
+                i += 1
+        keep_indices = {0}  # system
+        if len(self.messages) >= 2:
+            keep_indices.add(1)  # original user
+        # Keep last 3 productive pairs
+        for ai, ti in productive_pairs[-3:]:
+            for k in range(ai, ti + 1):
+                keep_indices.add(k)
+        kept = [self.messages[i] for i in sorted(keep_indices)]
+        if len(kept) >= len(self.messages):
+            return  # nothing actually got removed; bail
+        removed_count = len(self.messages) - len(kept)
+        # Inject a fresh "context-was-bloated" system note as a user-role
+        # message (so it's not seen as model self-talk) right after the
+        # original user task. The model reads this as "the task is still
+        # active; previous attempts didn't help; try a different approach."
+        surgery_note = LLMMessage(
+            role=Role.user,
+            content=(
+                f"[Drydock loop surgery] Your last {removed_count} messages "
+                f"got pruned because the same tool call signature fired "
+                f"{count}+ times with identical args and no progress. "
+                f"The locked-in retry pattern is gone. Re-read the task above, "
+                f"pick a DIFFERENT first action than what you were doing, "
+                f"and continue."
+            ),
+        )
+        kept.append(surgery_note)
+        self.messages.reset(kept)
+        self._last_loop_surgery_idx = len(self.messages)
+        # Reset the relevant tool-call history so the same sig can be
+        # tried fresh (just once). We don't wipe ALL history to keep
+        # other loop-prevention signals intact.
+        self._tool_call_history.pop(sig, None)
+        logger.warning(
+            "[LOOP-SURGERY] tool=%s sig=%s count=%d — pruned %d msgs, "
+            "kept %d productive frames + injected restart note",
+            tool_call.tool_name, sig[:8], count, removed_count, len(kept) - 1,
+        )
+
     def _circuit_breaker_check_OLD(self, tool_call: ResolvedToolCall) -> str | None:
         """OLD impl — kept for reference. Block exact-duplicate tool calls.
 
@@ -2874,6 +3013,13 @@ class AgentLoop:
         # nudges the model but must never stop the session — only
         # MAX_TOOL_TURNS (200) is a hard stop. See the 2026-04-16 stress
         # run where FORCED STOP poisoned every subsequent prompt.
+        # 2026-06-05: Context surgery on loop detection. When the same
+        # tool signature has fired 3+ times AND we haven't done surgery
+        # recently, REWRITE history: keep system + original user + last
+        # productive tool result + a NEW system note telling the model
+        # to start fresh. Breaks the locked-in pattern by changing what
+        # the model sees instead of just nudging.
+        self._maybe_perform_loop_surgery(tool_call)
         if blocked := self._circuit_breaker_check(tool_call):
             self._consecutive_circuit_breaker_fires += 1
             # 2026-05-18: render as `skipped` (yellow warning) not `error`

{drydock_cli-2.9.69 → drydock_cli-2.9.71}/drydock/core/tools/builtins/write_file.py

@@ -477,38 +477,17 @@ class WriteFile(
             except OSError:
                 hint = f"cwd: {cwd}"
 
-            # Always include recent reads if available — eliminates
-            # ambiguity on the very first miss, not just on retries.
+            # 2026-06-05: keep advisory SHORT. Long error text in
+            # tool result accumulates in context and reinforces the
+            # locked-in loop pattern. The loop-surgery hook handles
+            # actual recovery; this just gives one-line redirect.
             if recent_reads:
                 msg = (
-                    "NO `path` supplied to write_file. Pick ONE of "
-                    "these files you've recently read and pass its FULL "
-                    "absolute path as the `path` argument:\n  - "
-                    + "\n  - ".join(recent_reads[:5])
-                    + f"\n\nIf none of those is the file you intend to "
-                    f"edit, call read_file on the target file FIRST so "
-                    f"its path enters context, then call write_file "
-                    f"with `path` set to that exact path AND `content` "
-                    f"set to the full new file content. {hint}.\n\n"
-                    f"⚠ If you call write_file with NO path again you "
-                    f"will get this same advisory — that is NOT progress. "
-                    f"Switch to read_file, bash `ls`, or end your turn."
+                    f"path required. Try one of: "
+                    f"{', '.join(recent_reads[:3])}"
                 )
             else:
-                # No reads yet — must locate the target first.
-                msg = (
-                    "NO `path` supplied to write_file. You haven't read "
-                    "any files yet, so there is no obvious target. Do "
-                    "ONE of these:\n"
-                    "  1. Call `bash` with `ls` or `find` to locate the "
-                    "target file path under the current project\n"
-                    "  2. Call `read_file` on the file you intend to edit\n"
-                    "  3. End your turn with text if you're truly stuck\n"
-                    f"{hint}.\n\n"
-                    "⚠ Calling write_file again with NO path will "
-                    "produce this same advisory — not progress. Switch "
-                    "tools."
-                )
+                msg = "path required. Call ls or read_file first to locate the target."
             yield WriteFileResult(
                 path="(missing)",
                 bytes_written=0,

{drydock_cli-2.9.69 → drydock_cli-2.9.71}/pyproject.toml

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