drydock-cli 2.8.39__tar.gz → 2.8.40__tar.gz

drydock_cli-2.8.40/.auto_release.lock

@@ -0,0 +1 @@
+2045659

{drydock_cli-2.8.39 → drydock_cli-2.8.40}/PKG-INFO

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

@@ -802,9 +802,10 @@ class AgentLoop:
         # template the model can specialize. Off under pytest, on by default
         # in production. Opt out via DRYDOCK_CONSTRAINT_HINT=0.
         _constraint_hint_default = "0" if _under_pytest else "1"
-        if os.environ.get(
+        _constraint_hint_on = os.environ.get(
             "DRYDOCK_CONSTRAINT_HINT", _constraint_hint_default
-        ).strip().lower() not in ("0", "false", "no"):
+        ).strip().lower() not in ("0", "false", "no")
+        if _constraint_hint_on:
             try:
                 from drydock.core.constraint_hint import (
                     detect_constraint_shape, build_hint,
@@ -822,6 +823,26 @@ class AgentLoop:
                     "constraint hint failed (skipped): %s", _e, exc_info=True
                 )
 
+        # === AUTO-SOLVE (synthetic Z3 tool call) ===
+        # The escalation level above the advisory constraint hint: when
+        # the extractor produces a high-confidence ExtractResult AND Z3
+        # can actually decide it, we run Z3 ourselves and inject a
+        # synthetic solve() call + tool result. Models trust tool output
+        # as authoritative — much stronger signal than a system note.
+        # Same pattern as _auto_prefetch_retrieve for GraphRAG.
+        # Off under pytest. Opt out via DRYDOCK_AUTO_SOLVE=0.
+        _auto_solve_default = "0" if _under_pytest else "1"
+        if _constraint_hint_on and os.environ.get(
+            "DRYDOCK_AUTO_SOLVE", _auto_solve_default
+        ).strip().lower() not in ("0", "false", "no"):
+            try:
+                from drydock.core.auto_solve import maybe_inject_auto_solve
+                maybe_inject_auto_solve(self.messages, user_msg or "")
+            except Exception as _e:
+                logger.warning(
+                    "auto-solve failed (skipped): %s", _e, exc_info=True
+                )
+
         try:
             should_break_loop = False
             tool_turns = 0

drydock_cli-2.8.40/drydock/core/auto_solve.py

@@ -0,0 +1,329 @@
+"""Auto-solve hook — execute Z3 ourselves and inject a synthetic
+solve() tool call + result before the LLM turn begins.
+
+The escalation level above the smart-template engine. Even with a
+pre-filled template in a system note, Gemma 4 wasn't calling `solve`
+(0/153 sessions in the 2026-05-15 burndown). This module closes the
+gap by computing the answer with Z3 ourselves and presenting it to
+the model as authoritative tool output — same pattern as the
+GraphRAG auto-prefetch.
+
+Flow:
+    user message arrives
+        → constraint_extract.extract() pulls f(x) + predicate
+        → build SolveArgs from the ExtractResult
+        → run Solve tool synchronously (5-30s timeout)
+        → if Z3 succeeded with a confident result:
+            inject synthetic assistant message: tool_call=solve(...)
+            inject synthetic tool message:      result=Z3's actual answer
+            inject system note: "Use the count above as your answer."
+        → real LLM turn proceeds with the authoritative result in context
+
+Predicates handled:
+    perfect_square, perfect_cube — count integer (x,y) with y²=f(x)
+    equation_solve              — find integer solutions to f(x)=g(x)
+    smallest_with / largest_with — optimize min/max
+    divisible_by                 — count solutions in range with f(x)%k==0
+
+Skipped (Z3 can't decide):
+    prime — requires factoring; route via number_theory.is_prime in the
+            normal advisory template instead.
+
+Env gates:
+    DRYDOCK_AUTO_SOLVE=0   — disable the synthetic-tool-call path
+                              (smart-template advisory note still fires)
+    DRYDOCK_AUTO_SOLVE_TIMEOUT_MS=<int>  — per-Z3-call timeout, default 10000
+
+Safety:
+    - Bounds are heuristic (x ∈ [-200, 200]). If Z3 returns sat for a
+      bounded search, we report the count CONDITIONAL on the bound
+      ("4 solutions in [-200, 200]"). The model can override if it
+      knows the true range from the question.
+    - If Z3 returns unsat / unknown / timeout, we emit nothing. The
+      smart-template advisory falls through unchanged.
+    - The synthetic tool call uses op="find_all" / "optimize" matching
+      what the model would write — so messages.jsonl reads naturally.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import uuid
+from typing import TYPE_CHECKING
+
+logger = logging.getLogger("drydock.auto_solve")
+
+if TYPE_CHECKING:
+    from drydock.core.constraint_extract import ExtractResult
+
+
+# Bound heuristics per predicate (default search range for `find_all`
+# / `optimize`). These are intentionally narrow — Z3 enumerates within
+# the range and we report `len(models)`. The model can manually
+# re-call solve with a wider range if the problem demands it.
+_DEFAULT_BOUNDS = {
+    "perfect_square":  (-200, 200),
+    "perfect_cube":    (-200, 200),
+    "equation_solve":  (-200, 200),
+    "divisible_by":    (1, 100),
+    "smallest_with":   (1, 1000),
+    "largest_with":    (1, 1000),
+}
+
+
+def _build_args(extr: "ExtractResult") -> dict | None:
+    """Build the SolveArgs dict for this ExtractResult, or None if the
+    predicate isn't one Z3 can decide. The dict is what the model
+    *would* have written when calling the tool — used both for the
+    actual Z3 call and as the synthetic tool_call arguments.
+    """
+    if extr.predicate == "prime":
+        # Z3 can't check primality; advisory template routes via
+        # number_theory.is_prime instead.
+        return None
+    if not extr.variables:
+        return None
+
+    main_var = extr.variables[0]
+    lo, hi = _DEFAULT_BOUNDS.get(extr.predicate, (-100, 100))
+    vars_csv = ", ".join(f"{v}:Int" for v in extr.variables)
+
+    if extr.predicate == "perfect_square":
+        return {
+            "op": "find_all",
+            "variables": f"{vars_csv}, y:Int",
+            "constraints": [
+                f"y * y == {extr.formula}",
+                f"{main_var} >= {lo}", f"{main_var} <= {hi}",
+                "y >= 0",
+            ],
+            "limit": 100,
+            "timeout_ms": 30000,
+        }
+    if extr.predicate == "perfect_cube":
+        return {
+            "op": "find_all",
+            "variables": f"{vars_csv}, y:Int",
+            "constraints": [
+                f"y * y * y == {extr.formula}",
+                f"{main_var} >= {lo}", f"{main_var} <= {hi}",
+            ],
+            "limit": 100,
+            "timeout_ms": 30000,
+        }
+    if extr.predicate == "divisible_by":
+        return {
+            "op": "find_all",
+            "variables": vars_csv,
+            "constraints": [
+                f"({extr.formula}) % {extr.divisor} == 0",
+                f"{main_var} >= {lo}", f"{main_var} <= {hi}",
+            ],
+            "limit": 200,
+            "timeout_ms": 15000,
+        }
+    if extr.predicate == "equation_solve":
+        if not extr.second_formula:
+            return None
+        return {
+            "op": "find_all",
+            "variables": vars_csv,
+            "constraints": [
+                f"({extr.formula}) == ({extr.second_formula})",
+                f"{main_var} >= {lo}", f"{main_var} <= {hi}",
+            ],
+            "limit": 50,
+            "timeout_ms": 15000,
+        }
+    if extr.predicate in ("smallest_with", "largest_with"):
+        return {
+            "op": "optimize",
+            "variables": vars_csv,
+            "constraints": [
+                extr.formula,
+                f"{main_var} >= {lo}", f"{main_var} <= {hi}",
+            ],
+            "objective": main_var,
+            "direction": "min" if extr.predicate == "smallest_with" else "max",
+            "timeout_ms": 15000,
+        }
+    return None
+
+
+def _run_solve_sync(args_dict: dict) -> dict | None:
+    """Invoke the Solve tool with the given args and return the
+    SolveResult as a dict. Returns None on failure / timeout / unsat.
+    """
+    try:
+        from drydock.core.tools.base import BaseToolState
+        from drydock.core.tools.builtins.solve_tool import (
+            Solve, SolveArgs, SolveConfig, SolveResult,
+        )
+    except Exception as e:
+        logger.warning("[AUTO-SOLVE] could not import Solve tool: %s", e)
+        return None
+
+    try:
+        args = SolveArgs(**args_dict)
+    except Exception as e:
+        logger.warning("[AUTO-SOLVE] bad SolveArgs: %s; args=%s", e, args_dict)
+        return None
+
+    tool = Solve(config=SolveConfig(), state=BaseToolState())
+
+    async def _run() -> SolveResult | None:
+        result = None
+        async for ev in tool.run(args):
+            if isinstance(ev, SolveResult):
+                result = ev
+        return result
+
+    try:
+        # Hard wall clock — Z3's internal timeout is per-check; this
+        # bounds the whole orchestration including streaming setup.
+        wall_ms = int(args_dict.get("timeout_ms", 15000)) + 5000
+        result = asyncio.run(asyncio.wait_for(_run(), timeout=wall_ms / 1000))
+    except asyncio.TimeoutError:
+        logger.warning("[AUTO-SOLVE] hard timeout exceeded")
+        return None
+    except RuntimeError as e:
+        # Likely "asyncio.run() cannot be called from a running event loop"
+        # if we're somehow inside one — fall through.
+        logger.warning("[AUTO-SOLVE] asyncio error: %s", e)
+        return None
+    except Exception as e:  # noqa: BLE001 — solver failures must not crash drydock
+        logger.warning("[AUTO-SOLVE] solver failure: %s", e, exc_info=True)
+        return None
+
+    if result is None or not result.ok:
+        return None
+    return result.model_dump()
+
+
+def _format_result(args_dict: dict, result_dict: dict,
+                   extr: "ExtractResult") -> str:
+    """Render the Solve result the way the real Solve tool prints it,
+    matching what the model sees from a normal tool call. Adds a
+    one-line summary at the bottom so the model can extract the
+    answer in one read.
+    """
+    status = result_dict.get("status", "?")
+    model = result_dict.get("model", "")
+    models = result_dict.get("models", []) or []
+    obj = result_dict.get("objective_value", "")
+
+    parts = [f"status: {status}"]
+    if extr.predicate in ("perfect_square", "perfect_cube",
+                          "equation_solve", "divisible_by"):
+        # Counting questions — len(models) is the answer
+        parts.append(f"solutions found: {len(models)}")
+        if models:
+            parts.append("solutions:")
+            for m in models[:50]:
+                parts.append(f"  {m}")
+        # Single-line answer hint at the bottom
+        if status == "sat":
+            parts.append("")
+            parts.append(f"ANSWER: {len(models)}  "
+                         f"(Z3 enumerated all integer solutions to "
+                         f"`{args_dict['constraints'][0]}` in the bounded range "
+                         f"{args_dict['constraints'][1]} ∧ "
+                         f"{args_dict['constraints'][2]})")
+    elif extr.predicate in ("smallest_with", "largest_with"):
+        if status == "optimal" and obj:
+            parts.append(f"optimal value: {obj}")
+            parts.append(f"assignment: {model}")
+            parts.append("")
+            parts.append(f"ANSWER: {obj}")
+        else:
+            parts.append(f"model: {model}")
+    else:
+        parts.append(f"model: {model}")
+
+    return "\n".join(parts)
+
+
+def maybe_inject_auto_solve(messages_obj, user_msg: str) -> bool:
+    """Try to compute and inject a synthetic solve() call+result.
+
+    Returns True if the pair was injected, False otherwise. The
+    `messages_obj` is the agent_loop's `self.messages` — must
+    expose `.append(LLMMessage)`.
+
+    Env-gated by DRYDOCK_AUTO_SOLVE (default ON in production).
+    Safe to call repeatedly per turn; the caller is responsible for
+    not calling it twice for the same user message.
+    """
+    if os.environ.get("DRYDOCK_AUTO_SOLVE", "1").strip().lower() in (
+            "0", "false", "no"):
+        return False
+    if not user_msg or len(user_msg) < 10:
+        return False
+
+    try:
+        from drydock.core.constraint_extract import extract
+    except Exception as e:
+        logger.warning("[AUTO-SOLVE] could not import constraint_extract: %s", e)
+        return False
+
+    try:
+        extr = extract(user_msg)
+    except Exception as e:  # noqa: BLE001
+        logger.warning("[AUTO-SOLVE] extract failed: %s", e)
+        return False
+    if extr is None or extr.confidence < 0.5:
+        return False
+
+    args_dict = _build_args(extr)
+    if args_dict is None:
+        logger.warning("[AUTO-SOLVE] predicate %s not Z3-decidable", extr.predicate)
+        return False
+
+    logger.warning("[AUTO-SOLVE] running Z3 for predicate=%s formula=%r",
+                   extr.predicate, extr.formula[:80])
+    result_dict = _run_solve_sync(args_dict)
+    if result_dict is None:
+        return False
+    status = result_dict.get("status", "?")
+    if status not in ("sat", "optimal", "valid"):
+        # unsat / unknown / infeasible / countered: don't inject — the
+        # advisory template still works as a fallback and the model
+        # might do better by reasoning differently.
+        logger.warning("[AUTO-SOLVE] Z3 status=%s; not injecting", status)
+        return False
+
+    # Build synthetic assistant + tool messages
+    try:
+        from drydock.core.types import LLMMessage, Role, ToolCall, FunctionCall
+    except Exception as e:
+        logger.warning("[AUTO-SOLVE] could not import types: %s", e)
+        return False
+
+    call_id = f"auto-solve-{uuid.uuid4().hex[:16]}"
+    args_json = json.dumps(args_dict)
+    formatted = _format_result(args_dict, result_dict, extr)
+
+    synth_assistant = LLMMessage(
+        role=Role.assistant,
+        content="",
+        tool_calls=[
+            ToolCall(
+                id=call_id,
+                function=FunctionCall(name="solve", arguments=args_json),
+                type="function",
+            ),
+        ],
+    )
+    synth_tool = LLMMessage(
+        role=Role.tool,
+        content=formatted,
+        name="solve",
+        tool_call_id=call_id,
+    )
+    messages_obj.append(synth_assistant)
+    messages_obj.append(synth_tool)
+    logger.warning("[AUTO-SOLVE] injected synthetic solve call+result "
+                   "(predicate=%s, status=%s)", extr.predicate, status)
+    return True

{drydock_cli-2.8.39 → drydock_cli-2.8.40}/drydock/core/llm/backend/generic.py

@@ -191,27 +191,13 @@ class OpenAIAdapter(APIAdapter):
         )
 
         # Enable thinking for models that support it (Gemma 4)
-        _budget_env = os.environ.get("DRYDOCK_THINKING_BUDGET_TOKENS")
         if thinking and thinking not in ("off", ""):
             payload["chat_template_kwargs"] = {"enable_thinking": True}
-            # Cap thinking length (llama.cpp). Prevents runaway thinking stalls
-            # on hard HLE questions (model can think >480s without this).
-            # Set DRYDOCK_THINKING_BUDGET_TOKENS=8000 in HLE batch launches.
-            if _budget_env:
-                try:
-                    # llama.cpp requires thinking_budget inside chat_template_kwargs,
-                    # not as a top-level field (top-level is silently ignored → INT32_MAX).
-                    payload["chat_template_kwargs"]["thinking_budget"] = int(_budget_env)
-                except ValueError:
-                    pass
-        elif _budget_env:
-            # llama.cpp activates reasoning with budget=INT32_MAX by default even
-            # when thinking="off". Always cap it when the env var is set so that
-            # "off"-mode requests don't stall for 480s on hard questions.
-            try:
-                payload.setdefault("chat_template_kwargs", {})["thinking_budget"] = int(_budget_env)
-            except ValueError:
-                pass
+        # NOTE: thinking budget (max thinking tokens) is a llamacpp SERVER startup
+        # flag (--reasoning-budget N / LLAMA_ARG_THINK_BUDGET), not an API parameter.
+        # The Gemma4 jinja template does not expose a thinking_budget variable, so
+        # chat_template_kwargs.thinking_budget is silently ignored. Update
+        # start_gemma4_llamacpp.sh to set --reasoning-budget on the next container start.
 
         if enable_streaming:
             payload["stream"] = True

{drydock_cli-2.8.39 → drydock_cli-2.8.40}/pyproject.toml

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

drydock_cli-2.8.40/tests/test_auto_solve.py

@@ -0,0 +1,229 @@
+"""Tests for the auto-solve synthetic-tool-call hook."""
+from __future__ import annotations
+
+import os
+from unittest.mock import patch
+
+import pytest
+
+from drydock.core.auto_solve import (
+    _build_args,
+    _format_result,
+    _run_solve_sync,
+    maybe_inject_auto_solve,
+)
+from drydock.core.constraint_extract import ExtractResult, extract
+
+
+# ── _build_args ─────────────────────────────────────────────────────────
+
+def test_build_args_perfect_square():
+    extr = ExtractResult(
+        predicate="perfect_square",
+        formula="x * x * x - 1",
+        variables=["x"],
+    )
+    args = _build_args(extr)
+    assert args is not None
+    assert args["op"] == "find_all"
+    assert args["variables"] == "x:Int, y:Int"
+    assert "y * y == x * x * x - 1" in args["constraints"][0]
+    assert "y >= 0" in args["constraints"]
+
+
+def test_build_args_divisible_by():
+    extr = ExtractResult(
+        predicate="divisible_by",
+        formula="x * x + 1",
+        variables=["x"],
+        divisor=5,
+    )
+    args = _build_args(extr)
+    assert args is not None
+    assert "(x * x + 1) % 5 == 0" in args["constraints"][0]
+
+
+def test_build_args_equation_solve():
+    extr = ExtractResult(
+        predicate="equation_solve",
+        formula="x * x - 5 * x + 6",
+        second_formula="0",
+        variables=["x"],
+    )
+    args = _build_args(extr)
+    assert args is not None
+    assert "(x * x - 5 * x + 6) == (0)" in args["constraints"][0]
+
+
+def test_build_args_smallest_with_uses_optimize():
+    extr = ExtractResult(
+        predicate="smallest_with",
+        formula="n * n > 1000",
+        variables=["n"],
+    )
+    args = _build_args(extr)
+    assert args is not None
+    assert args["op"] == "optimize"
+    assert args["direction"] == "min"
+    assert args["objective"] == "n"
+
+
+def test_build_args_largest_with_uses_max():
+    extr = ExtractResult(
+        predicate="largest_with",
+        formula="x * x < 50",
+        variables=["x"],
+    )
+    args = _build_args(extr)
+    assert args is not None
+    assert args["op"] == "optimize"
+    assert args["direction"] == "max"
+
+
+def test_build_args_returns_none_for_prime():
+    """Z3 can't decide primality — caller should fall through to the
+    advisory template, which routes prime checks via number_theory."""
+    extr = ExtractResult(
+        predicate="prime",
+        formula="n * n + n + 41",
+        variables=["n"],
+    )
+    assert _build_args(extr) is None
+
+
+def test_build_args_returns_none_for_empty_variables():
+    extr = ExtractResult(
+        predicate="perfect_square",
+        formula="0",
+        variables=[],
+    )
+    assert _build_args(extr) is None
+
+
+# ── _run_solve_sync (real Z3) ───────────────────────────────────────────
+
+def test_run_solve_sync_perfect_square_hle_classic():
+    """The HLE x^3 - 16x^2 - 72x + 1056 perfect-square question.
+    Verifies the synthetic-tool-call path returns the correct count (4)
+    when called end-to-end with no mocking."""
+    args = {
+        "op": "find_all",
+        "variables": "x:Int, y:Int",
+        "constraints": [
+            "y * y == x*x*x - 16*x*x - 72*x + 1056",
+            "x >= -200", "x <= 200", "y >= 0",
+        ],
+        "limit": 100,
+        "timeout_ms": 30000,
+    }
+    result = _run_solve_sync(args)
+    assert result is not None
+    assert result["status"] == "sat"
+    assert len(result["models"]) == 4
+    xs = {int(m.split(",")[0].split("=")[1]) for m in result["models"]}
+    assert xs == {-4, 4, 17, 65}
+
+
+def test_run_solve_sync_returns_none_for_unsat():
+    args = {
+        "op": "find_all",
+        "variables": "x:Int",
+        "constraints": ["x > 0", "x < 0"],
+        "limit": 5,
+    }
+    result = _run_solve_sync(args)
+    # unsat is still ok-status, just empty models. _run_solve_sync
+    # returns the dict; the caller decides what to do.
+    assert result is not None
+    assert result["status"] == "unsat"
+
+
+# ── _format_result ──────────────────────────────────────────────────────
+
+def test_format_result_emits_answer_line_for_counting():
+    extr = ExtractResult(
+        predicate="perfect_square",
+        formula="x*x*x - 1",
+        variables=["x"],
+    )
+    args = {"constraints": ["y*y == x*x*x - 1", "x >= -200", "x <= 200", "y >= 0"]}
+    result = {"status": "sat", "models": ["x=1, y=0", "x=2, y=2"], "model": "", "objective_value": ""}
+    out = _format_result(args, result, extr)
+    assert "solutions found: 2" in out
+    assert "ANSWER: 2" in out
+
+
+def test_format_result_emits_answer_for_optimize():
+    extr = ExtractResult(
+        predicate="smallest_with",
+        formula="n*n > 1000",
+        variables=["n"],
+    )
+    args = {"constraints": []}
+    result = {"status": "optimal", "model": "n=32", "objective_value": "32",
+              "models": []}
+    out = _format_result(args, result, extr)
+    assert "ANSWER: 32" in out
+
+
+# ── maybe_inject_auto_solve (orchestration) ─────────────────────────────
+
+class _StubMessages:
+    """Minimal stand-in for the agent_loop's `self.messages` —
+    just records what was appended."""
+    def __init__(self):
+        self.items = []
+
+    def append(self, item):
+        self.items.append(item)
+
+
+def test_maybe_inject_appends_pair_for_z3_solvable():
+    msgs = _StubMessages()
+    q = "For how many integers x is x^3 - 1 a perfect square?"
+    with patch.dict(os.environ, {"DRYDOCK_AUTO_SOLVE": "1"}, clear=False):
+        ok = maybe_inject_auto_solve(msgs, q)
+    assert ok is True
+    # Synthetic assistant + tool messages should both be appended.
+    assert len(msgs.items) == 2
+    # First: assistant with tool_calls
+    assert msgs.items[0].role.value == "assistant" or str(msgs.items[0].role).endswith("assistant")
+    assert msgs.items[0].tool_calls
+    assert msgs.items[0].tool_calls[0].function.name == "solve"
+    # Second: tool with the formatted result
+    assert "ANSWER:" in msgs.items[1].content
+
+
+def test_maybe_inject_skips_when_disabled():
+    msgs = _StubMessages()
+    q = "For how many integers x is x^3 - 1 a perfect square?"
+    with patch.dict(os.environ, {"DRYDOCK_AUTO_SOLVE": "0"}, clear=False):
+        ok = maybe_inject_auto_solve(msgs, q)
+    assert ok is False
+    assert msgs.items == []
+
+
+def test_maybe_inject_skips_when_no_extract_match():
+    msgs = _StubMessages()
+    with patch.dict(os.environ, {"DRYDOCK_AUTO_SOLVE": "1"}, clear=False):
+        ok = maybe_inject_auto_solve(msgs, "Build me a calculator.")
+    assert ok is False
+    assert msgs.items == []
+
+
+def test_maybe_inject_skips_for_prime_predicate():
+    """Prime checks require factoring — caller falls through to the
+    advisory template which routes via number_theory.is_prime."""
+    msgs = _StubMessages()
+    q = "For how many positive integers n is n^2 + n + 41 prime?"
+    with patch.dict(os.environ, {"DRYDOCK_AUTO_SOLVE": "1"}, clear=False):
+        ok = maybe_inject_auto_solve(msgs, q)
+    assert ok is False
+    assert msgs.items == []
+
+
+def test_maybe_inject_skips_for_short_message():
+    msgs = _StubMessages()
+    with patch.dict(os.environ, {"DRYDOCK_AUTO_SOLVE": "1"}, clear=False):
+        ok = maybe_inject_auto_solve(msgs, "hi")
+    assert ok is False