drydock-cli 2.7.38__tar.gz → 2.7.40__tar.gz

drydock_cli-2.7.40/.auto_release.lock

@@ -0,0 +1 @@
+2806441

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.38
+Version: 2.7.40
 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.7.38 → drydock_cli-2.7.40}/drydock/cli/textual_ui/widgets/messages.py

@@ -118,6 +118,16 @@ _SENTENCE_BOUNDARY_RE = re.compile(r"(?<=[.!?]) (?=[A-Z])")
 _INLINE_CAPWORD_HEADING_RE = re.compile(
     r"(?<=[.!?]) (?=[A-Z][A-Za-z]{1,15}:\s)"
 )
+# Issue #16: quantized Gemma 4 (Q3_K_M) strips whitespace tokens, jamming
+# `### Header text body` and `* item * item * item` runs onto one line.
+# These patterns insert paragraph breaks before inline markdown headers
+# and asterisk bullets that weren't preceded by a real newline.
+_INLINE_ATX_HEADING_RE = re.compile(r"(?<=[.!?\)]) (?=#{1,4} [A-Z])")
+# Asterisk-bullet rescue. Accepts either case for the first bullet word
+# (file names start lowercase, sentences start uppercase). Requires the
+# bullet word to be ≥3 alpha chars + dot/space — guards against math
+# (`2 * 3`) and inline emphasis (`a * b`).
+_INLINE_ASTERISK_BULLET_RE = re.compile(r"(?<=[a-zA-Z.!?\)]) (?=\* [A-Za-z][A-Za-z0-9_]{2,})")
 
 
 def _sentence_chunks(text: str, group: int = 2) -> str:
@@ -164,6 +174,10 @@ def _break_walls_of_text(text: str) -> str:
     out = _INLINE_ENUM_RE.sub("\n", out)
     out = _INLINE_DASH_BULLET_RE.sub("\n", out)
     out = _INLINE_CAPWORD_HEADING_RE.sub("\n\n", out)
+    # Issue #16: rescue inline ATX headers (`### Foo`) and asterisk bullets
+    # (`* item`) that quantized Gemma 4 emits without surrounding newlines.
+    out = _INLINE_ATX_HEADING_RE.sub("\n\n", out)
+    out = _INLINE_ASTERISK_BULLET_RE.sub("\n", out)
     # If inline markers didn't produce any breaks AND the text is long
     # enough that one paragraph hurts readability, split at sentence
     # boundaries. group=1 = each sentence on its own paragraph (most

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/drydock/core/agent_loop.py

@@ -693,6 +693,25 @@ class AgentLoop:
         _ar_t1 = time.perf_counter()
         logger.warning("[TIMING] _auto_route_task: %.2fs", _ar_t1 - _ar_t0)
 
+        # === AUTO-PREFETCH RETRIEVE ===
+        # HLE Phase 1 finding (memory: project_graphrag_underused.md): Gemma 4
+        # almost never calls retrieve() on its own for general-knowledge
+        # questions — it defaults to web_search instead. So a curated
+        # GraphRAG corpus is invisible to the model unless we surface it
+        # automatically. This hook runs retrieve(query=user_msg[:300]) and,
+        # if there are real hits (above a quality threshold), prepends them
+        # as a system note BEFORE the first LLM call. Zero behavior change
+        # when the index has nothing relevant; pure lift when it does.
+        #
+        # Env-gated via DRYDOCK_AUTO_RETRIEVE so existing workflows are
+        # unaffected. Set to "1" or "true" to enable.
+        if os.environ.get("DRYDOCK_AUTO_RETRIEVE", "").strip().lower() in ("1", "true", "yes"):
+            logger.warning("[AUTO-RETRIEVE] hook entry, query=%r", (user_msg or "")[:80])
+            try:
+                self._auto_prefetch_retrieve(user_msg)
+            except Exception as _e:
+                logger.warning("auto-prefetch retrieve failed (skipped): %s", _e, exc_info=True)
+
         try:
             should_break_loop = False
             tool_turns = 0
@@ -1885,7 +1904,39 @@ class AgentLoop:
         if len(cleaned) != len(self.messages):
             self.messages.reset(cleaned)
 
-        # Fix 2: If last message is assistant, add a user "Continue." prompt.
+        # Fix 2: Drop empty assistant messages (no content AND no tool_calls).
+        # These violate the OpenAI schema and cause 400 errors on the next LLM
+        # call. They arise when the model returns only thinking/reasoning tokens
+        # (which get stripped) and stall-retry exhaustion leaves the empty msg
+        # in history. An assistant message that follows a tool result must have
+        # either content or tool_calls; if neither, drop it along with any
+        # orphaned tool result messages that precede it (to keep role ordering
+        # valid).
+        cleaned2: list[LLMMessage] = []
+        for msg in self.messages:
+            if (msg.role == Role.assistant
+                    and not (msg.content or "").strip()
+                    and not msg.tool_calls):
+                # Skip empty assistant — also drop any immediately preceding
+                # tool result that would be truly orphaned (no matching
+                # assistant.tool_calls entry in the preceding messages).
+                while cleaned2 and cleaned2[-1].role == Role.tool:
+                    preceding_tool = cleaned2[-1]
+                    tcid = getattr(preceding_tool, "tool_call_id", None)
+                    if tcid and any(
+                        m.role == Role.assistant
+                        and m.tool_calls
+                        and any(tc.id == tcid for tc in m.tool_calls)
+                        for m in cleaned2[:-1]
+                    ):
+                        break  # tool result has a valid match; keep it
+                    cleaned2.pop()
+            else:
+                cleaned2.append(msg)
+        if len(cleaned2) != len(self.messages):
+            self.messages.reset(cleaned2)
+
+        # Fix 3: If last message is assistant, add a user "Continue." prompt.
         # The auto-Continue exists so Gemma 4 keeps executing multi-step plans
         # without stopping prematurely at an intermediate text response. For
         # stress runs against prompts that don't need tool calls (pure
@@ -2032,22 +2083,37 @@ class AgentLoop:
             temp = active_model.temperature
             extra_sampling: dict | None = None
 
+            # Per-model `extra_params` (top_k, top_p, frequency_penalty,
+            # max_tokens, etc.) declared in config.toml flow through
+            # extra_sampling. This is the seam llama.cpp users need to
+            # pass top_k=40, top_p=0.95, frequency_penalty=1.1 per the
+            # Gemma 4 loop-fix recipe.
+            cfg_extra = getattr(active_model, "extra_params", None) or {}
+            if cfg_extra:
+                extra_sampling = dict(cfg_extra)
+
             # Token-level loop-breaker: when repetition is detected, bump
             # temperature and add frequency_penalty + a fresh seed so the
             # model's next completion is mechanically likely to diverge.
             # Mistral/OpenAI-compat backends pass these straight through
-            # to vLLM's SamplingParams.
+            # to vLLM's SamplingParams. These OVERRIDE config.extra_params
+            # for the duration of the loop-break.
             if getattr(self, "_loop_detected", False):
                 signal = getattr(self, "_loop_signal", "") or ""
                 # Heavier bump if we've already hit the FORCE_STOP signal
                 # (=8 repeats) vs a WARNING (=3-5 repeats).
                 heavy = signal == "FORCE_STOP"
                 temp = min(1.0, temp + (0.5 if heavy else 0.3))
-                extra_sampling = {
+                # Merge loop-breaker overrides on top of any cfg_extra so
+                # config-declared sampling params survive when a loop is
+                # NOT detected, and get overridden when one IS detected.
+                if extra_sampling is None:
+                    extra_sampling = {}
+                extra_sampling.update({
                     "frequency_penalty": 0.7 if heavy else 0.4,
                     "presence_penalty": 0.3,
                     "seed": int(time.time() * 1000) & 0x7FFFFFFF,
-                }
+                })
                 logger.info(
                     "[LOOP-BREAK] %s → temp %.2f, freq_pen %.2f, seed %d",
                     signal, temp, extra_sampling["frequency_penalty"],
@@ -2776,6 +2842,133 @@ class AgentLoop:
 
         return None
 
+    def _auto_prefetch_retrieve(self, user_msg: str) -> None:
+        """Auto-fetch relevant chunks from GraphRAG and inject as system note.
+
+        Runs synchronously (the GraphRAG retriever is a fast SQLite query).
+        Caps the query length at 300 chars and the injected context at 2000
+        chars to avoid blowing context budget on long user prompts.
+
+        Quality gate: only inject if at least one text-chunk hit has score
+        >= 8.0 (the indexer's score is roughly TF-IDF magnitude). Below
+        that, the retrieval is probably noise and would just bloat the
+        prompt.
+
+        See memory/project_graphrag_underused.md for why this exists:
+        Gemma 4 doesn't call retrieve() on its own for general-knowledge
+        questions, so a curated index is invisible without a hook like
+        this one.
+        """
+        try:
+            from drydock.graphrag import Index
+            db = os.environ.get("DRYDOCK_GRAPHRAG_DB") or str(
+                Path.home() / ".drydock" / "graphrag.sqlite"
+            )
+            if not Path(db).is_file():
+                logger.warning("[AUTO-RETRIEVE] db missing: %s", db)
+                return
+            idx = Index(db)
+        except Exception as e:
+            logger.warning("[AUTO-RETRIEVE] setup failed: %s", e, exc_info=True)
+            return
+
+        # Extract the actual question from boilerplate. HLE-style prompts
+        # are wrapped: "Answer this question. End your response with...
+        # QUESTION: <real text>". Without this strip the retrieve query
+        # matches scaffolding (CLAUDE.md learnings, etc.) instead of the
+        # actual content. Also strip "FINAL ANSWER:" trailing instructions.
+        raw = (user_msg or "")
+        q_marker = raw.find("QUESTION:")
+        if q_marker >= 0:
+            raw = raw[q_marker + len("QUESTION:"):]
+        # Drop trailing answer-format instructions
+        for stopper in ("FINAL ANSWER:", "Your answer", "Format your", "End your response"):
+            idx_ = raw.find(stopper)
+            if idx_ > 50:  # only strip if there's still meaningful content
+                raw = raw[:idx_]
+        query = raw.strip()[:400]
+        if len(query) < 10:
+            logger.warning("[AUTO-RETRIEVE] query too short (%d chars)", len(query))
+            return
+        logger.warning("[AUTO-RETRIEVE] extracted query: %r", query[:120])
+
+        try:
+            result = idx.retrieve(query, symbol_limit=0, text_limit=4)
+        except Exception as e:
+            logger.warning("[AUTO-RETRIEVE] query failed: %s", e, exc_info=True)
+            return
+
+        text_hits = getattr(result, "text", None) or getattr(result, "text_hits", []) or []
+        QUALITY_THRESHOLD = 8.0
+        good_hits = [h for h in text_hits if getattr(h, "score", 0) >= QUALITY_THRESHOLD]
+        logger.warning("[AUTO-RETRIEVE] %d total hits, %d above threshold %.1f",
+                       len(text_hits), len(good_hits), QUALITY_THRESHOLD)
+        if not good_hits:
+            return
+
+        # Build the system note. Cap at ~2000 chars total.
+        chunks = []
+        budget = 2000
+        for h in good_hits[:3]:
+            text = (getattr(h, "content", "") or "").strip()
+            score = float(getattr(h, "score", 0))
+            file_ = getattr(h, "file", "") or "?"
+            s, e = getattr(h, "start_line", 0), getattr(h, "end_line", 0)
+            piece = f"--- {file_}:{s}-{e} (score={score:.1f}) ---\n{text}"
+            if len(piece) > budget:
+                piece = piece[:budget] + "..."
+            chunks.append(piece)
+            budget -= len(piece) + 4
+            if budget <= 0:
+                break
+
+        # SYNTHETIC TOOL CALL: instead of mutating the user message
+        # (which iter6-9 proved is treated as scaffolding by Gemma 4 — it
+        # ignores inline references and trusts its training prior), spawn
+        # a fake assistant->tool message pair that LOOKS like the model
+        # called retrieve() and got results. Models trust tool outputs
+        # as authoritative input.
+        #
+        # Sequence:
+        #   user -> [our synthetic assistant with tool_call retrieve]
+        #        -> [our synthetic tool result with the chunks]
+        #        -> real LLM turn begins from there
+        from drydock.core.types import ToolCall, FunctionCall as _FC
+        import uuid
+
+        tool_call_id = f"auto-retrieve-{uuid.uuid4().hex[:16]}"
+        tool_args = json.dumps({"query": (user_msg or "")[:200]})
+        synth_assistant = LLMMessage(
+            role=Role.assistant,
+            content="",
+            tool_calls=[
+                ToolCall(
+                    id=tool_call_id,
+                    function=_FC(name="retrieve", arguments=tool_args),
+                    type="function",
+                )
+            ],
+        )
+        # Format chunks as the retrieve tool's actual output shape.
+        formatted = "=== TEXT ===\n\n" + "\n\n".join(chunks)
+        synth_tool = LLMMessage(
+            role=Role.tool,
+            content=formatted,
+            name="retrieve",
+            tool_call_id=tool_call_id,
+        )
+        self.messages.append(synth_assistant)
+        self.messages.append(synth_tool)
+
+        logger.warning(
+            "[AUTO-RETRIEVE] synthesized retrieve tool result: %d chunks "
+            "(top score %.1f, content %d chars), msgs now %d",
+            len(chunks),
+            max(float(getattr(h, "score", 0)) for h in good_hits),
+            len(formatted),
+            len(self.messages),
+        )
+
     async def _auto_route_task(self, user_msg: str) -> None:
         """Lightweight auto-context: list project files and key docs.
 

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/drydock/core/config/_settings.py

@@ -238,6 +238,18 @@ class ModelConfig(BaseModel):
     output_price: float = 0.0  # Price per million output tokens
     thinking: Literal["off", "low", "medium", "high"] = "off"
     auto_compact_threshold: int = 200_000
+    # Free-form sampling overrides forwarded to the LLM backend's
+    # extra_sampling (top_k, top_p, frequency_penalty, repeat_penalty,
+    # min_p, max_tokens, etc). Anything supported by the OpenAI-compat
+    # server. For llama.cpp + Gemma 4 the article-recommended config is:
+    #   [models.extra_params]
+    #   top_k = 40
+    #   top_p = 0.95
+    #   frequency_penalty = 1.1
+    #   max_tokens = 2048
+    # Set temperature via the top-level `temperature` field; do not
+    # duplicate it here.
+    extra_params: dict[str, Any] = Field(default_factory=dict)
 
     @model_validator(mode="before")
     @classmethod

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/drydock/core/config/local_detect.py

@@ -117,4 +117,17 @@ def patch_config_for_local(
         for model in models:
             if isinstance(model, dict) and model.get("alias") == "local":
                 model["name"] = info.model_name
+                # When the detected backend is llama.cpp, bake in the
+                # Gemma 4 anti-loop sampling recipe (article: i-built-a-
+                # gemma-4-ai-agent-it-kept-looping). Temperature must be
+                # 1.0; lower values reinforce loops on quantized GGUF.
+                # Don't clobber user-defined values if config was already
+                # touched.
+                if info.label == "llama.cpp":
+                    model.setdefault("temperature", 1.0)
+                    extra = model.setdefault("extra_params", {})
+                    extra.setdefault("top_k", 40)
+                    extra.setdefault("top_p", 0.95)
+                    extra.setdefault("frequency_penalty", 1.1)
+                    extra.setdefault("max_tokens", 2048)
                 break

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/drydock/core/prompts/gemma4.md

@@ -140,3 +140,12 @@ When you're asked to BUILD a package: always also write a
 `strong_tests.sh` that exercises the PRD's specific examples and
 roundtrip/state properties. A package with only `functional_tests.sh`
 is not finished.
+
+FORMATTING — when answering with prose (not tool calls):
+- Always put a BLANK LINE before any `###`/`##`/`#` header.
+- Always put a BLANK LINE between paragraphs.
+- Always put a BLANK LINE before the FIRST item of a bullet list and a
+  newline between items. Do NOT pack `* a * b * c` onto one line.
+- Use `\n\n` between sections. Quantized models drop whitespace tokens
+  to save length; the renderer cannot always recover the original
+  structure if you do.

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/drydock/core/steering_hook.py

@@ -52,7 +52,9 @@ def _initialize() -> _CachedSteering | None:
 
     try:
         from drydock.steering import (
+            LogitBiasSteeringApplier,
             LogOnlySteeringApplier,
+            NullSteeringApplier,
             SteeringConfig,
             load_registry,
         )
@@ -63,13 +65,23 @@ def _initialize() -> _CachedSteering | None:
     root = os.environ.get("DRYDOCK_STEERING_ROOT") or None
     registry = load_registry(root)
     config = SteeringConfig.from_mode_names(mode_names)
-    # Default applier is log-only — a real applier (vLLM sidecar etc.)
-    # is the next-phase deliverable. The seam is the same either way.
-    applier = LogOnlySteeringApplier()
+    # Applier selection via DRYDOCK_STEERING_APPLIER:
+    #   "log_only" (default)  : log-only, no inference change
+    #   "logit_bias"          : token-level steering via vLLM logit_bias
+    #                            (manifest must carry tags.tokens_boost
+    #                            and/or tags.tokens_suppress)
+    #   "null"                : no-op (same as not setting MODES at all)
+    # Real activation steering (VllmSidecarSteeringApplier) lands later.
+    kind = os.environ.get("DRYDOCK_STEERING_APPLIER", "log_only").strip().lower()
+    if kind == "logit_bias":
+        applier = LogitBiasSteeringApplier()
+    elif kind == "null":
+        applier = NullSteeringApplier()
+    else:
+        applier = LogOnlySteeringApplier()
     logger.info(
-        "steering: enabled, modes=%s, registry=%s",
-        mode_names,
-        registry.root,
+        "steering: enabled, modes=%s, applier=%s, registry=%s",
+        mode_names, applier.kind, registry.root,
     )
     return _CachedSteering(config=config, registry=registry, applier=applier)
 

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/drydock/core/tools/builtins/bash.py

@@ -586,6 +586,10 @@ class Bash(
             state = self.state.__dict__.setdefault("_bash_history", {})
             # Track total error-exit calls per command (regardless of output).
             err_state = self.state.__dict__.setdefault("_bash_err_count", {})
+            # Track total run count per exact command regardless of output or
+            # exit code.  Catches benchmark/timeit loops where output varies
+            # each run (timings differ) so the hash check never fires.
+            run_count_state = self.state.__dict__.setdefault("_bash_run_count", {})
             # Track consecutive empty-stdout search commands (any command, not
             # just identical ones).  The model semantic-loops by trying different
             # search terms for a non-existent target:
@@ -595,6 +599,73 @@ class Bash(
             _consec_empty_search_state = self.state.__dict__.setdefault(
                 "_consec_empty_searches", {"count": 0}
             )
+            # python -c / python3 -c SyntaxError loop-breaker.
+            # The model truncates multi-line inline scripts; each re-run
+            # produces a SyntaxError but with slightly different stderr
+            # (different column/line), so the hash check never fires.
+            # Track cross-command: any python3 -c that hits SyntaxError.
+            _python_c_err_state = self.state.__dict__.setdefault(
+                "_python_c_syntaxerr_count", 0
+            )
+            _is_python_c_syntaxerr = (
+                returncode != 0
+                and "SyntaxError" in stderr_raw
+                and bool(__import__("re").search(r"\bpython3?\s+-c\b", args.command))
+            )
+            if _is_python_c_syntaxerr:
+                self.state.__dict__["_python_c_syntaxerr_count"] = _python_c_err_state + 1
+                if _python_c_err_state >= 1:
+                    _cnt = _python_c_err_state + 1
+                    yield self._build_result(
+                        command=args.command,
+                        stdout=(
+                            f"[LOOP-BREAKER: `python3 -c '...'` has hit SyntaxError "
+                            f"{_cnt} times. Inline -c scripts get truncated by the "
+                            f"shell when they contain newlines or quotes. "
+                            f"Write the script to a file first, then run it:\n"
+                            f"  write_file path='/tmp/script.py' content='...'\n"
+                            f"  bash command='python3 /tmp/script.py'\n"
+                            f"Do NOT retry the inline -c form again.]"
+                        ),
+                        stderr="",
+                        returncode=returncode,
+                    )
+                    return
+
+            # Exact-command repetition loop-breaker: fires when the same
+            # command text is run 5+ times regardless of output or exit code.
+            # Catches benchmark/timeit/import-check loops where each run has
+            # varying output (timings, object ids) that defeats the hash check.
+            # Excludes commands that write files (heredoc, redirect, sed -i)
+            # since those legitimately run the same form multiple times.
+            _is_write_cmd = bool(
+                __import__("re").search(
+                    r"(>|>>|\bsed\s+-i\b|\btee\b|\bcat\s+<<|\bprintf\b.*>)",
+                    args.command,
+                )
+            )
+            if not _is_write_cmd:
+                _run_cnt = run_count_state.get(args.command, 0) + 1
+                run_count_state[args.command] = _run_cnt
+                if _run_cnt >= 5:
+                    cmd_preview = args.command[:80]
+                    yield self._build_result(
+                        command=args.command,
+                        stdout=(
+                            f"[LOOP-BREAKER: `{cmd_preview}` has been run "
+                            f"{_run_cnt} times this session with the same "
+                            f"command text. The output is stable — re-running "
+                            f"it will not produce new information. "
+                            f"Stop repeating this command and move on to the "
+                            f"next task step. If you are benchmarking, one "
+                            f"run is enough. If you are checking an import, "
+                            f"the result is already known.]\n{stdout}"
+                        ),
+                        stderr=stderr,
+                        returncode=returncode,
+                    )
+                    return
+
             if returncode != 0:
                 err_count = err_state.get(args.command, 0) + 1
                 err_state[args.command] = err_count

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/drydock/core/tools/builtins/search_replace.py

@@ -1069,6 +1069,17 @@ class SearchReplace(
 
                 if fuzzy_context:
                     error_msg += f"\n{fuzzy_context}"
+                elif "not found anywhere" in context:
+                    # First search line not found at all — embed file head so the
+                    # model can craft a correct SEARCH block without calling read_file.
+                    head_lines = current_content.split("\n")[:30]
+                    head = "\n".join(head_lines)
+                    error_msg += (
+                        f"\nFile head (first {len(head_lines)} lines of actual content):\n"
+                        f"```\n{head}\n```\n"
+                        "Read the file head above and craft your SEARCH block using "
+                        "text that actually appears in the file."
+                    )
 
                 error_msg += (
                     "\nDebugging tips:\n"

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/pyproject.toml

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

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/scripts/hle_eval.py

@@ -210,10 +210,15 @@ def score_answer(q: dict, pred: str) -> dict:
 def notify_telegram(tag: str, message: str) -> None:
     """Fire-and-forget Telegram ping via the existing notify_release.py.
 
-    All HLE runs notify on start, every MILESTONE_EVERY completions, and
-    on final completion (or crash). Failures are silent — a missed
-    Telegram is never worth crashing the eval.
+    Default OFF: HLE eval is too noisy for routine notifications and the
+    user explicitly asked to stop. Opt in via HLE_TELEGRAM=1 if you want
+    start/milestone/final/crash pings for a specific run.
+
+    Failures are silent — a missed Telegram is never worth crashing
+    the eval.
     """
+    if os.environ.get("HLE_TELEGRAM", "").strip().lower() not in ("1", "true", "yes"):
+        return
     if not NOTIFY.exists():
         return
     import subprocess

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/scripts/notify_release.py

@@ -51,6 +51,17 @@ if __name__ == "__main__":
         version = sys.argv[1] if len(sys.argv) > 1 else "unknown"
         summary = "New release"
 
+    # User explicitly asked to stop HLE telegram spam (2026-05-04).
+    # Drop HLE-prefixed tags by default; override with HLE_TELEGRAM=1.
+    # This silences the in-flight overnight HLE process too — it shells
+    # out to this script per ping, so the filter applies retroactively.
+    import os as _os
+    if (version.startswith("hle-")
+            and _os.environ.get("HLE_TELEGRAM", "").strip().lower()
+            not in ("1", "true", "yes")):
+        print(f"[notify_release] dropped HLE-tagged ping: {version}")
+        sys.exit(0)
+
     if version == "status":
         # Hourly status — plain text, no Markdown parsing issues
         msg = f"⚓ {summary}"

{drydock_cli-2.7.38 → drydock_cli-2.7.40}/tests/test_issue_fixes.py

@@ -1,4 +1,4 @@
-"""Regression tests for GitHub issues #4, #5, #6."""
+"""Regression tests for GitHub issues #4, #5, #6, #14."""
 from __future__ import annotations
 
 import os
@@ -116,3 +116,103 @@ class TestIssue6BashAllowlistBasename:
         # Returns None (caller prompts for approval) — not ALWAYS.
         from drydock.core.tools.base import ToolPermission
         assert res != ToolPermission.ALWAYS
+
+
+# Issue #14: empty assistant messages (no content, no tool_calls) persist in
+# history after stall-retry exhaustion and cause 400 errors on the next turn.
+# _sanitize_message_ordering must drop them before the next LLM call.
+
+class TestIssue14EmptyAssistantDropped:
+    def _make_minimal_agent(self):
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import MessageList
+        al = object.__new__(AgentLoop)
+        al.messages = MessageList()
+        # stubs for methods called by _sanitize_message_ordering
+        al._truncate_old_tool_results = lambda: None
+        al._proactive_prune_write_oscillation = lambda: None
+        import os as _os
+        al._os = _os
+        return al
+
+    def test_empty_assistant_dropped(self):
+        """Empty assistant message (no content, no tool_calls) is dropped."""
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import LLMMessage, Role, MessageList
+        import os
+        al = object.__new__(AgentLoop)
+        al.messages = MessageList()
+        al._truncate_old_tool_results = lambda: None
+        al._proactive_prune_write_oscillation = lambda: None
+
+        al.messages.append(LLMMessage(role=Role.user, content="hello"))
+        al.messages.append(LLMMessage(role=Role.assistant, content=None))  # empty — bug
+
+        original_env = os.environ.get("DRYDOCK_AUTO_CONTINUE_DISABLE")
+        os.environ["DRYDOCK_AUTO_CONTINUE_DISABLE"] = "1"
+        try:
+            al._sanitize_message_ordering()
+        finally:
+            if original_env is None:
+                os.environ.pop("DRYDOCK_AUTO_CONTINUE_DISABLE", None)
+            else:
+                os.environ["DRYDOCK_AUTO_CONTINUE_DISABLE"] = original_env
+
+        roles = [m.role for m in al.messages]
+        assert Role.assistant not in roles, f"Empty assistant must be dropped; got {roles}"
+
+    def test_empty_assistant_with_preceding_tool_result_both_dropped(self):
+        """Tool result immediately before an empty assistant is also dropped
+        to avoid a dangling tool message with no matching assistant turn."""
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import LLMMessage, Role, MessageList, ToolCall, FunctionCall
+        import os
+        al = object.__new__(AgentLoop)
+        al.messages = MessageList()
+        al._truncate_old_tool_results = lambda: None
+        al._proactive_prune_write_oscillation = lambda: None
+
+        al.messages.append(LLMMessage(role=Role.user, content="do it"))
+        al.messages.append(LLMMessage(
+            role=Role.assistant,
+            content=None,
+            tool_calls=[ToolCall(id="c1", function=FunctionCall(name="bash", arguments="{}"))],
+        ))
+        al.messages.append(LLMMessage(role=Role.tool, content="ok", tool_call_id="c1"))
+        al.messages.append(LLMMessage(role=Role.assistant, content=None))  # empty — bug
+
+        os.environ["DRYDOCK_AUTO_CONTINUE_DISABLE"] = "1"
+        try:
+            al._sanitize_message_ordering()
+        finally:
+            os.environ.pop("DRYDOCK_AUTO_CONTINUE_DISABLE", None)
+
+        roles = [m.role for m in al.messages]
+        # The empty assistant AND its preceding orphan tool result should be gone
+        assert roles == [Role.user, Role.assistant, Role.tool] or roles == [Role.user], \
+            f"Unexpected roles after sanitize: {roles}"
+        # The productive assistant (with tool_calls) must survive
+        productive = [m for m in al.messages if m.role == Role.assistant]
+        assert all(m.tool_calls for m in productive), "Non-empty assistant must keep tool_calls"
+
+    def test_non_empty_assistant_preserved(self):
+        """Assistant messages with content are never dropped."""
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import LLMMessage, Role, MessageList
+        import os
+        al = object.__new__(AgentLoop)
+        al.messages = MessageList()
+        al._truncate_old_tool_results = lambda: None
+        al._proactive_prune_write_oscillation = lambda: None
+
+        al.messages.append(LLMMessage(role=Role.user, content="hi"))
+        al.messages.append(LLMMessage(role=Role.assistant, content="I'm here"))
+
+        os.environ["DRYDOCK_AUTO_CONTINUE_DISABLE"] = "1"
+        try:
+            al._sanitize_message_ordering()
+        finally:
+            os.environ.pop("DRYDOCK_AUTO_CONTINUE_DISABLE", None)
+
+        roles = [m.role for m in al.messages]
+        assert Role.assistant in roles, "Non-empty assistant must not be dropped"