drydock-cli 2.8.30__tar.gz → 2.8.31__tar.gz

drydock_cli-2.8.31/.auto_release.lock

@@ -0,0 +1 @@
+1740481

{drydock_cli-2.8.30 → drydock_cli-2.8.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.30
+Version: 2.8.31
 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
@@ -48,6 +48,7 @@ Requires-Dist: tomli-w>=1.2.0
 Requires-Dist: tree-sitter-bash>=0.25.1
 Requires-Dist: tree-sitter>=0.25.2
 Requires-Dist: watchfiles>=1.1.1
+Requires-Dist: z3-solver>=4.16.0
 Requires-Dist: zstandard>=0.25.0
 Description-Content-Type: text/markdown
 

{drydock_cli-2.8.30 → drydock_cli-2.8.31}/drydock/core/agent_loop.py

@@ -787,6 +787,34 @@ class AgentLoop:
             except Exception as _e:
                 logger.warning("curiosity gap logging failed (skipped): %s", _e)
 
+        # === CONSTRAINT-SHAPE DETECTOR ===
+        # The solve tool (Z3-backed) is the right answer for "find x such
+        # that ...", optimization, prove-from-premises, mod-arithmetic, and
+        # logic-puzzle questions. Gemma 4 doesn't reach for it on its own —
+        # this hook recognises the shape and injects a worked-example
+        # 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(
+            "DRYDOCK_CONSTRAINT_HINT", _constraint_hint_default
+        ).strip().lower() not in ("0", "false", "no"):
+            try:
+                from drydock.core.constraint_hint import (
+                    detect_constraint_shape, build_hint,
+                )
+                hit = detect_constraint_shape(user_msg or "")
+                if hit is not None:
+                    label, example = hit
+                    logger.warning(
+                        "[CONSTRAINT-HINT] matched %s; injecting template",
+                        label,
+                    )
+                    self._inject_system_note(build_hint(label, example))
+            except Exception as _e:
+                logger.warning(
+                    "constraint hint failed (skipped): %s", _e, exc_info=True
+                )
+
         try:
             should_break_loop = False
             tool_turns = 0
@@ -853,24 +881,30 @@ class AgentLoop:
                 # DRYDOCK_STOP_NOW_TIME_SEC regardless of turn count.
                 # Helps HLE batches where per-turn latency is 60-160s
                 # and the turn-based STOP_NOW fires too late or not at all.
+                #
+                # IMPORTANT: check most-extreme condition FIRST. If a single
+                # LLM generation spans all three thresholds (e.g. starts at
+                # 200s, returns at 480s), the loop only gets one check at
+                # 480s. The old if/elif order would fire the *first* injection
+                # at 480s instead of the hard-stop. Reversed order ensures the
+                # hard-stop always wins when we're past all thresholds.
                 if (STOP_NOW_TIME_SEC > 0
-                        and not _time_stop_injected
-                        and _elapsed > STOP_NOW_TIME_SEC):
-                    _time_stop_injected = True
-                    _stop_suffix = os.environ.get("DRYDOCK_STOP_NOW_SUFFIX", "")
-                    self._inject_system_note(
-                        f"Time limit reached: {int(_elapsed)}s elapsed on "
-                        "this single request. STOP NOW. Emit a final text "
-                        "response summarizing what you have or your best "
-                        "guess."
-                        + (f" {_stop_suffix}" if _stop_suffix else "")
+                        and _elapsed > STOP_NOW_TIME_SEC + 120):
+                    # Past all injection thresholds — hard-stop unconditionally.
+                    yield AssistantEvent(
+                        content=(
+                            f"\n\n[Drydock: hard time limit ({int(_elapsed)}s) reached. "
+                            "No final answer was provided before the deadline.]\n"
+                        ),
+                        stopped_by_middleware=True,
                     )
+                    return
                 elif (STOP_NOW_TIME_SEC > 0
-                        and _time_stop_injected
                         and not _time_stop_escalated
                         and _elapsed > STOP_NOW_TIME_SEC + 60):
-                    # Model made another tool call after the first STOP_NOW.
-                    # Escalate: one more forceful injection, then let it run out.
+                    # Model made another tool call after the first STOP_NOW
+                    # (or missed it entirely). Escalate with a forceful injection.
+                    _time_stop_injected = True
                     _time_stop_escalated = True
                     _stop_suffix = os.environ.get("DRYDOCK_STOP_NOW_SUFFIX", "")
                     self._inject_system_note(
@@ -879,6 +913,18 @@ class AgentLoop:
                         "If uncertain, still write an answer."
                         + (f" {_stop_suffix}" if _stop_suffix else "")
                     )
+                elif (STOP_NOW_TIME_SEC > 0
+                        and not _time_stop_injected
+                        and _elapsed > STOP_NOW_TIME_SEC):
+                    _time_stop_injected = True
+                    _stop_suffix = os.environ.get("DRYDOCK_STOP_NOW_SUFFIX", "")
+                    self._inject_system_note(
+                        f"Time limit reached: {int(_elapsed)}s elapsed on "
+                        "this single request. STOP NOW. Emit a final text "
+                        "response summarizing what you have or your best "
+                        "guess."
+                        + (f" {_stop_suffix}" if _stop_suffix else "")
+                    )
                 if tool_turns == WRAP_UP_WARN_AT:
                     self._inject_system_note(
                         f"You have used {tool_turns} tool calls on this "
@@ -3137,7 +3183,8 @@ class AgentLoop:
             for p in ('"total_count": 0', '"total_count":0',
                       'total_count: 0', 'retrieved 0 todos',
                       'no todos', '0 tasks', 'no tasks',
-                      'no results', 'no matches', '0 matches'):
+                      'no results', 'no matches', '0 matches',
+                      'no relevant information found'):
                 if p in s:
                     return True
             return False

drydock_cli-2.8.31/drydock/core/constraint_hint.py

@@ -0,0 +1,181 @@
+"""Constraint-question detector — nudges Gemma 4 toward the `solve` tool.
+
+The model has the `solve` tool available, but it doesn't reliably reach
+for it. Two observed failure modes:
+  1. It answers from prior — guesses a value that "looks right."
+  2. It tries to enumerate by hand and miscounts.
+
+This hook pattern-matches the user message against the canonical
+shapes of constraint problems (find-x-such-that, prove, optimization,
+mod arithmetic, logic puzzle vocabulary). On a match, it picks the
+worked example closest to the question shape and injects it as a
+system note. That gives the model a concrete template to specialize
+rather than abstract advice.
+
+Same shape as the GraphRAG auto-prefetch and the curiosity-gap
+logger: env-gated, log-only on miss, idempotent within a single
+user-prompt turn.
+
+Disabled via DRYDOCK_CONSTRAINT_HINT=0.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import re
+
+logger = logging.getLogger("drydock.constraint_hint")
+
+
+# Pattern → (label, worked-example string). Patterns are evaluated in
+# order; the first matching pattern wins. Each example shows the
+# variables/constraints encoding for that question shape, so the model
+# can specialize rather than invent the encoding from scratch.
+_PATTERN_HINTS: list[tuple[re.Pattern[str], str, str]] = [
+    (
+        re.compile(
+            r"\b(einstein|zebra)\s+puzzle\b"
+            r"|\blogic\s+puzzle\b"
+            r"|\bwho\s+(lives|owns|drinks|smokes)\b"
+            r"|\b(?:n|\d+)[\s\-]?queens\b"
+            r"|\bsudoku\b",
+            re.IGNORECASE,
+        ),
+        "logic-puzzle",
+        'solve(op="solve", variables="a:Int, b:Int, c:Int",\n'
+        '      constraints=[\n'
+        '        "a >= 1", "a <= 3", "b >= 1", "b <= 3", "c >= 1", "c <= 3",\n'
+        '        "Distinct(a, b, c)",      # all-different\n'
+        '        "a == 1",                  # \\"X is in position 1\\"\n'
+        '        "Abs(b - a) == 1",         # \\"Y is next to X\\"\n'
+        '        "c != 2",                  # \\"Z is not in position 2\\"\n'
+        '      ])\n'
+        '→ sat: a=1, b=2, c=3',
+    ),
+    (
+        re.compile(
+            r"\bmod(?:ulo|ular)?\b"
+            r"|\bmod\s*\d"
+            r"|\(mod\s+\w+\)"
+            r"|\b\d+\s*[≡=]\s*\d+\s*\(?mod"
+            r"|[a-zA-Z]\s*%\s*\d+"  # `n % 7`, `x%5`
+            r"|\bdivisible\s+by\b"
+            r"|\bremainder\b",
+            re.IGNORECASE,
+        ),
+        "modular-arithmetic",
+        'solve(op="solve", variables="x:Int",\n'
+        '      constraints=["x >= 0", "x < 7", "3*x % 7 == 5"])\n'
+        '→ sat: x=4    (smallest non-negative x with 3x ≡ 5 mod 7)\n'
+        '\n'
+        'For \\"find all solutions in the range\\", use op="find_all".\n'
+        'For \\"smallest x with property P\\", use op="optimize", direction="min".',
+    ),
+    (
+        re.compile(
+            r"\bmaxim(?:ize|um)\b|\bminim(?:ize|um)\b"
+            r"|\bsmallest\s+(?:value|integer|number|x|n)\b"
+            r"|\blargest\s+(?:value|integer|number|x|n)\b"
+            r"|\bsubject\s+to\b"
+            r"|\boptimize\b",
+            re.IGNORECASE,
+        ),
+        "optimization",
+        'solve(op="optimize", variables="x:Int, y:Int",\n'
+        '      constraints=["x + y == 10", "x >= 0", "y >= 0"],\n'
+        '      objective="x * y", direction="max")\n'
+        '→ optimal: x=5, y=5, objective=25',
+    ),
+    (
+        re.compile(
+            r"\b(prove|show\s+that|demonstrate|verify\s+that)\b"
+            r"|\bif\s+and\s+only\s+if\b"
+            r"|\biff\b"
+            r"|\bnecessary\s+and\s+sufficient\b",
+            re.IGNORECASE,
+        ),
+        "prove",
+        'solve(op="prove", variables="x:Int",\n'
+        '      constraints=["x > 0"],\n'
+        '      conclusion="x + 1 > 1")\n'
+        '→ valid     (constraints entail the conclusion)\n'
+        '\n'
+        'When `prove` returns `countered`, the `model` field is the\n'
+        'counterexample — that IS the answer for \\"is this true\\" questions.',
+    ),
+    (
+        re.compile(
+            r"\bfind\s+(?:all\s+)?(?:x|y|n|the\s+(?:value|values|number|integer|integers))\s+such\s+that\b"
+            r"|\bfor\s+what\s+(?:value|values|x|y|n)\s+(?:does|is|of)\b"
+            r"|\bexists\s+(?:a|an)\s+\w+\s+such\s+that\b"
+            r"|\bthere\s+(?:is|exists)\s+(?:a|an|some)\s+\w+\s+(?:such\s+that|with)\b",
+            re.IGNORECASE,
+        ),
+        "find-such-that",
+        'solve(op="solve", variables="x:Int, y:Int",\n'
+        '      constraints=["x + y == 10", "x - y == 4"])\n'
+        '→ sat: x=7, y=3\n'
+        '\n'
+        'Variable types: Int | Real | Bool | BitVec<N>. Operators: ==, !=,\n'
+        '<, <=, >, >=, +, -, *, /, %. Functions: And, Or, Not, Implies,\n'
+        'If, Distinct, Abs, Sum.',
+    ),
+]
+
+
+def _strip_boilerplate(text: str) -> str:
+    """Pull the actual question out of HLE / shakedown wrappers.
+
+    Same surgery as the GraphRAG auto-prefetch — \"QUESTION:\" prefix and
+    \"FINAL ANSWER:\" / \"Format your\" suffix get stripped so patterns
+    don't false-match on scaffolding.
+    """
+    s = text or ""
+    marker = s.find("QUESTION:")
+    if marker >= 0:
+        s = s[marker + len("QUESTION:"):]
+    for stopper in ("FINAL ANSWER:", "Format your", "End your response",
+                    "Your answer"):
+        idx = s.find(stopper)
+        # Strip iff there's at least a real question in front (>=20 chars).
+        # The original auto-prefetch used 50; we use a smaller threshold
+        # here so short questions like "Solve x+1=5.\nFINAL ANSWER:" still
+        # match.
+        if idx >= 20:
+            s = s[:idx]
+    return s.strip()
+
+
+def detect_constraint_shape(user_msg: str) -> tuple[str, str] | None:
+    """Return (label, worked_example) when the message has a
+    constraint-problem shape, or None otherwise.
+
+    Patterns are checked in priority order: logic-puzzle first (most
+    specific), then modular arithmetic, optimization, prove, and finally
+    the broad \"find x such that\" catchall. The first match wins.
+    """
+    cleaned = _strip_boilerplate(user_msg)
+    if len(cleaned) < 10:
+        return None
+    for pat, label, example in _PATTERN_HINTS:
+        if pat.search(cleaned):
+            return (label, example)
+    return None
+
+
+def build_hint(label: str, example: str) -> str:
+    """Format a system note around the worked example.
+
+    Kept compact (≈350 chars) so it doesn't dominate the context.
+    Frames the example as \"specialize THIS template,\" not \"here's an
+    abstract guideline\" — the project memory says Gemma 4 trusts
+    concrete shapes and ignores prose advice.
+    """
+    return (
+        f"[constraint-hint] This question has a {label} shape. "
+        f"Encode as a `solve` call rather than reasoning step-by-step. "
+        f"Z3 is sound and complete on integer/real/boolean constraints. "
+        f"Template to specialize:\n\n{example}\n\n"
+        f"See the `constraint-reasoning` skill for the full encoding "
+        f"reference (Int/Real/Bool/BitVec, Distinct, If, Sum, Implies)."
+    )

{drydock_cli-2.8.30 → drydock_cli-2.8.31}/drydock/core/prompts/gemma4.md

@@ -4,7 +4,7 @@ ACT IMMEDIATELY. Your FIRST response must be a tool call — not text. Do NOT ex
 
 When answering a direct factual or math question (not writing code), you MUST write visible text — never produce a response with only thinking tokens and no visible content. End your response with "FINAL ANSWER: <your answer>" on its own line so the judge can extract it. Even if you are uncertain, always attempt an answer and write "FINAL ANSWER: <best guess>" — an empty response scores 0 regardless of how good your reasoning was.
 
-Your tools: read_file, write_file, search_replace, grep, glob, bash, task, web_search, web_fetch, retrieve, math, count, memory, verify, logic, algebra, number_theory, set, linear_algebra, stats, units, chemistry.
+Your tools: read_file, write_file, search_replace, grep, glob, bash, task, web_search, web_fetch, retrieve, math, count, memory, verify, logic, algebra, number_theory, set, linear_algebra, stats, units, chemistry, solve.
 
 CURIOSITY — default posture is "investigate, then assert" (SOVEREIGN_PRD §5.7):
 - If the user message names a thing you don't have context for (paper title,
@@ -222,6 +222,36 @@ Fe2(SO4)3, C6H12O6). Examples:
   chemistry(op="empirical_formula", percents="C=40, H=6.7, O=53.3") → CH2O
 Use INSTEAD of looking up atomic weights / doing stoichiometry by hand.
 
+USE THE solve TOOL when the question is a CONSTRAINT problem — "find x
+such that ...", "find all values where ...", "what's the smallest /
+largest x with ...", logic puzzles (Einstein-style), Sudoku-shape
+problems, modular arithmetic ranges, or any "prove this follows from
+those premises." Backed by Z3 (SMT solver). It is COMPLETE and SOUND
+for integer/real arithmetic + boolean logic. Don't enumerate by hand.
+  solve(op="solve", variables="x:Int, y:Int", constraints=["x + y == 10", "x - y == 4"])
+    → sat: x=7, y=3
+  solve(op="solve", variables="x:Int", constraints=["x >= 0", "x < 7", "3*x % 7 == 5"])
+    → sat: x=4   (smallest x with 3x ≡ 5 mod 7)
+  solve(op="find_all", variables="x:Int", constraints=["x >= 1", "x <= 5"], limit=10)
+    → all 5 solutions
+  solve(op="prove", variables="x:Int", constraints=["x > 0"], conclusion="x + 1 > 1")
+    → valid
+  solve(op="optimize", variables="x:Int, y:Int", constraints=["x + y == 10", "x >= 0", "y >= 0"],
+        objective="x * y", direction="max")  → optimal: x=5, y=5 (objective=25)
+Variable types: Int, Real, Bool, BitVec<N>. Constraint operators: ==,
+!=, <, <=, >, >=, +, -, *, /, %, And, Or, Not, Implies, If, Distinct,
+Abs, Sum. When `prove` returns `countered`, the `model` field is the
+counterexample — use it as the answer.
+
+Reach for solve when the question has the shape:
+- "find <values> such that ..." / "for what x does ..."
+- "is there an x such that ..." (sat) or "for all x, ..." (prove)
+- a list of 3+ conditions over the same variable(s)
+- "Einstein puzzle", "Sudoku", "N-queens", "logic puzzle"
+- "modular arithmetic", "x mod N", "≡ ... (mod ...)"
+- "smallest / largest / maximize / minimize ... subject to ..."
+- "prove X from Y, Z" with constraints over integers/reals/booleans
+
 Rules:
 - Create files immediately. Do not plan or discuss — write code.
 - Use absolute imports for Python packages